@angular/core 6.0.3 → 6.0.7

package/bundles/core.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/core/core.umd.js"],"names":["global","factory","exports","module","require","define","amd","ng","core","rxjs","operators","this","extendStatics","Object","setPrototypeOf","__proto__","Array","d","b","p","hasOwnProperty","__extends","__","constructor","prototype","create","__assign","assign","t","s","i","n","arguments","length","call","__values","o","m","Symbol","iterator","next","value","done","__read","r","e","ar","push","error","__spread","concat","defineInjectable","opts","providedIn","undefined","defineInjector","options","providers","imports","InjectionToken","_desc","ngMetadataName","ngInjectableDef","toString","ANNOTATIONS","PARAMETERS","PROP_METADATA","makeDecorator","name","props","parentClass","chainFn","typeFn","metaCtor","makeMetadataCtor","DecoratorFactory","args","_i","apply","_a","annotationInstance","bind","TypeDecorator","cls","defineProperty","annotationCls","ctor","values","propName","makeParamDecorator","ParamDecoratorFactory","ParamDecorator","annotation","unusedKey","index","parameters","makePropDecorator","PropDecoratorFactory","decoratorInstance","PropDecorator","target","meta","unshift","ChangeDetectionStrategy","ChangeDetectorStatus","Query","ANALYZE_FOR_ENTRY_COMPONENTS","Attribute","attributeName","ContentChildren","selector","data","first","isViewQuery","descendants","ContentChild","ViewChildren","ViewChild","ɵChangeDetectorStatus","Directive","dir","Component","c","changeDetection","Default","Pipe","pure","Input","bindingPropertyName","Output","HostBinding","hostPropertyName","HostListener","eventName","Type","Function","isType","v","__window","window","__self","self","WorkerGlobalScope","__global","_global","promise","Promise","resolve","_symbolIterator","getSymbolIterator","Symbol_1","keys","getOwnPropertyNames","Map","key","scheduleMicroTask","fn","Zone","then","current","looseIdentical","a","isNaN","stringify","token","map","join","overriddenName","res","newLineIndex","indexOf","substring","DELEGATE_CTOR","INHERITED_CLASS","INHERITED_CLASS_WITH_CTOR","ReflectionCapabilities","reflect","_reflect","isReflectionEnabled","_zipTypesAndAnnotations","paramTypes","paramAnnotations","result","_ownParameters","type","parentCtor","typeStr","exec","tsickleCtorParams","ctorParameters","paramTypes_1","ctorParam","paramAnnotations_1","convertTsickleDecoratorIntoMetadata","decorators","getOwnMetadata","fill","getParentCtor","_ownAnnotations","typeOrFunc","annotations","ownAnnotations","_ownPropMetadata","propMetadata","propDecorators","propDecorators_1","propMetadata_1","forEach","prop","parentPropMetadata_1","ownPropMetadata","hasLifecycleHook","lcProperty","guards","getter","setter","method","importUri","resourceUri","resolveIdentifier","moduleUrl","members","runtime","resolveEnum","enumIdentifier","decoratorInvocations","decoratorInvocation","parentProto","getPrototypeOf","forwardRef","forwardRefFn","__forward_ref__","resolveForwardRef","Inject","Optional","Self","SkipSelf","Host","SOURCE","_THROW_IF_NOT_FOUND","THROW_IF_NOT_FOUND","INJECTOR","NullInjector","get","notFoundValue","Error","Injector","parent","isArray","StaticInjector","NULL","inject","IDENT","EMPTY","CIRCULAR","MULTI_PROVIDER_FN","slice","GET_PROPERTY_NAME$1","USE_VALUE$1","getClosureSafeProperty$1","objWithPropertyToExtract","provide","String","useValue","NULL_INJECTOR","NEW_LINE","NO_NEW_LINE","source","records","_records","set","deps","useNew","recursivelyProcessProviders","provider","staticError","resolvedProvider","resolveProvider","computeDeps","providerDeps","j","useExisting","useFactory","useClass","multi","multiProvider","multiProviderMixError","record","flags","tryResolveToken","resolveToken","depRecords","depRecord","childRecord","tokenPath","message","formatError","tokens","text","obj","charAt","substr","context","parts","JSON","replace","_currentInjector","setCurrentInjector","injector","former","injectableDef","injectArgs","types","arg","GET_PROPERTY_NAME","USE_VALUE","getClosureSafeProperty","EMPTY_ARRAY","convertInjectableProviderToFactory","deps_1","reflectionCapabilities","valueProvider_1","existingProvider_1","factoryProvider_1","classProvider_1","deps_2","deps_3","ViewEncapsulation","Injectable","injectableType","NgModule","ngModule","moduleType","metadata","ngInjectorDef","Version","VERSION","full","major","split","minor","patch","ERROR_DEBUG_CONTEXT","ERROR_ORIGINAL_ERROR","ERROR_LOGGER","getDebugContext","getOriginalError","defaultErrorLogger","console","ErrorHandler","_console","handleError","originalError","_findOriginalError","_findContext","errorLogger","getErrorLogger","constructResolvingPath","findFirstClosedCycle","reverse","k","injectionError","constructResolvingMessage","errMsg","wrappedError","msg","addKey","injectors","noAnnotationError","params","signature","ii","parameter","ReflectiveKey","id","displayName","_globalKeyRegistry","numberOfKeys","enumerable","configurable","KeyRegistry","_allKeys","has","newKey","size","reflector","Reflector","updateCapabilities","caps","identifier","ReflectiveDependency","optional","visibility","fromKey","_EMPTY_LIST","ResolvedReflectiveProvider_","resolvedFactories","resolvedFactory","ResolvedReflectiveFactory","dependencies","resolveReflectiveProvider","resolveReflectiveFactory","factoryFn","resolvedDeps","_dependenciesFor","aliasInstance","constructDependencies","params_1","_extractToken","resolveReflectiveProviders","resolvedProviderMap","mergeResolvedReflectiveProviders","normalizedProvidersMap","existing","_normalizeProviders","invalidProviderError","from","some","_createDependency","paramMetadata","UNDEFINED","ReflectiveInjector","resolveAndCreate","ResolvedReflectiveProviders","fromResolvedProviders","ReflectiveInjector_","_providers","_parent","_constructionCounter","len","keyIds","objs","_getByKey","resolveAndCreateChild","createChildFromResolved","inj","resolveAndInstantiate","instantiateResolved","_instantiateProvider","getProviderAtIndex","outOfBoundsError","_new","_getMaxNumberOfObjects","cyclicDependencyError","_instantiate","ResolvedReflectiveFactory$$1","_this","dep","_getByReflectiveDependency","instantiationError","originalException","originalStack","INJECTOR_KEY","_getByKeySelf","_getByKeyDefault","_getObjByKeyId","keyId","_throwOrNull","noProviderError","inj_","_mapProviders","APP_ROOT","NOT_YET","CIRCULAR$1","EMPTY_ARRAY$1","NULL_INJECTOR$1","getNullInjector","R3Injector","def","injectorDefTypes","Set","onDestroy","destroyed","deepForEach","injectorDef","processInjectorType","makeRecord","isRootInjector","defType","destroy","assertNotDestroyed","service","ngOnDestroy","clear","previousInjector","couldBeInjectableType","injectableDefInScope","injectableDefRecord","hydrate","defOrWrappedDef","parents","add","imported","delete","processProvider","isTypeProvider","providerToRecord","isValueProvider","isExistingProvider","isFactoryProvider","classRef_1","hasDeps","multiRecord_1","hasOnDestroy","input","isPromise","APP_INITIALIZER","ApplicationInitStatus","appInits","initialized","donePromise","rej","reject","runInitializers","asyncInitPromises","complete","initResult","all","catch","APP_ID","_appIdRandomProviderFactory","_randomChar","APP_ID_RANDOM_PROVIDER","fromCharCode","Math","floor","random","PLATFORM_INITIALIZER","PLATFORM_ID","APP_BOOTSTRAP_LISTENER","PACKAGE_ROOT_URL","Console","log","warn","ModuleWithComponentFactories","ngModuleFactory","componentFactories","_throwError","Compiler","compileModuleSync","compileModuleAsync","compileModuleAndAllComponentsSync","compileModuleAndAllComponentsAsync","clearCache","clearCacheFor","COMPILER_OPTIONS","CompilerFactory","ComponentRef","ComponentFactory","noComponentFactoryError","component","ERROR_COMPONENT","trace","events","_NullComponentFactoryResolver","resolveComponentFactory","ComponentFactoryResolver","CodegenComponentFactoryResolver","factories","_ngModule","_factories","componentType","ComponentFactoryBoundToModule","_super","ngContentSelectors","inputs","outputs","projectableNodes","rootSelectorOrNode","NgModuleRef","NgModuleFactory","detectWTF","wtf","createScope","leave","scope","returnValue","leaveScope","startTimeRange","rangeType","action","beginTimeRange","endTimeRange","range","wtfEnabled","noopScope","arg0","arg1","wtfCreateScope","wtfLeave","wtfStartTimeRange","wtfEndTimeRange","EventEmitter","isAsync","__isAsync","emit","subscribe","generatorOrNext","schedulerFn","errorFn","err","completeFn","setTimeout","sink","Subscription","Subject","NgZone","_b","enableLongStackTrace","hasPendingMicrotasks","hasPendingMacrotasks","isStable","onUnstable","onMicrotaskEmpty","onStable","onError","assertZonePatched","_nesting","_outer","_inner","fork","forkInnerZoneWithAngularBehavior","zone","properties","isAngularZone","onInvokeTask","delegate","task","applyThis","applyArgs","onEnter","invokeTask","onLeave","onInvoke","callback","invoke","onHasTask","hasTaskState","hasTask","change","microTask","checkStable","macroTask","onHandleError","runOutsideAngular","isInAngularZone","assertInAngularZone","assertNotInAngularZone","run","runTask","scheduleEventTask","EMPTY_PAYLOAD","noop","cancelTask","runGuarded","_platform","NoopNgZone","Testability","_ngZone","_pendingCount","_isZoneStable","_didWork","_callbacks","_watchAngularEvents","taskTrackingZone","_runCallbacksIfReady","increasePendingRequestCount","decreasePendingRequestCount","cb","pop","clearTimeout","timeoutId","doneCb","pending_1","getPendingTasks","filter","updateCb","macroTasks","isPeriodic","delay","creationLocation","xhr","addCallback","timeout","whenStable","getPendingRequestCount","findProviders","using","exactMatch","TestabilityRegistry","_applications","_testabilityGetter","addToWindow","registerApplication","testability","unregisterApplication","unregisterAllApplications","getTestability","elem","getAllTestabilities","getAllRootElements","findTestabilityInTree","findInAncestors","_NoopGetTestability","registry","_devMode","_runModeLocked","ALLOW_MULTIPLE_PLATFORMS","isDevMode","NgProbeToken","createPlatform","PlatformRef","inits","init","createPlatformFactory","parentPlatformFactory","desc","marker","extraProviders","platform","getPlatform","injectedProviders","assertPlatform","requiredToken","_injector","_modules","_destroyListeners","_destroyed","bootstrapModuleFactory","moduleFactory","ngZone","getNgZone","ngZoneOption","ngZoneInjector","moduleRef","exceptionHandler","remove","_callAndReportToErrorHandler","errorHandler","initStatus","_moduleDoBootstrap","bootstrapModule","compilerOptions","compilerFactory","optionsReducer","createCompiler","appRef","ApplicationRef","_bootstrapComponents","f","bootstrap","instance","ngDoBootstrap","listener","dst","reduce","_zone","_exceptionHandler","_componentFactoryResolver","_initStatus","_bootstrapListeners","_views","_runningTick","_enforceNoNewChanges","_stable","componentTypes","components","tick","isCurrentlyStable","Observable","observer","stableSub","unstableSub","unsubscribe","merge","pipe","share","componentOrFactory","componentFactory","compRef","_unloadComponent","location","nativeElement","_loadComponent","_tickScope","view","detectChanges","checkNoChanges","attachView","viewRef","attachToAppRef","detachView","detachFromAppRef","componentRef","hostView","list","el","splice","RendererStyleFlags2","RenderComponentType","templateUrl","slotCount","encapsulation","styles","animations","RenderDebugInfo","Renderer","RootRenderer","RendererFactory2","Renderer2","ElementRef","NgModuleFactoryLoader","moduleFactories","QueryList","dirty","_results","changes","find","toArray","reset","flatten","flat","item","flatItem","last","notifyOnChanges","setDirty","SystemJsNgModuleLoaderConfig","DEFAULT_CONFIG","factoryPathPrefix","factoryPathSuffix","SystemJsNgModuleLoader","_compiler","config","_config","load","path","loadFactory","loadAndCompile","exportName","System","import","checkNotEmpty","factoryClassSuffix","modulePath","ChangeDetectorRef","TemplateRef","ViewContainerRef","ViewRef","EmbeddedViewRef","EventListener","DebugNode","nativeNode","_debugContext","DebugElement","addChild","listeners","references","providerTokens","attributes","classes","childNodes","child","removeChild","childIndex","insertChildrenAfter","newChildren","siblingIndex","insertBefore","refChild","newChild","refIndex","query","predicate","queryAll","matches","_queryElementChildren","queryAllNodes","_queryNodeChildren","node","triggerEventHandler","eventObj","element","parentNode","_nativeNodeToDebugNode","getDebugNode","indexDebugNode","devModeEqual","isListLikeIterableA","isListLikeIterable","isListLikeIterableB","areIterablesEqual","comparator","iterator1","iterator2","item1","item2","WrappedValue","wrapped","wrap","unwrap","isWrapped","SimpleChange","previousValue","currentValue","firstChange","isFirstChange","isJsObject","DefaultIterableDifferFactory","supports","trackByFn","DefaultIterableDiffer","trackByIdentity","_linkedRecords","_unlinkedRecords","_previousItHead","_itHead","_itTail","_additionsHead","_additionsTail","_movesHead","_movesTail","_removalsHead","_removalsTail","_identityChangesHead","_identityChangesTail","_trackByFn","forEachItem","_next","forEachOperation","nextIt","nextRemove","addRemoveOffset","moveOffsets","getPreviousIndex","adjPreviousIndex","currentIndex","_nextRemoved","previousIndex","localMovePreviousIndex","localCurrentIndex","offset","forEachPreviousItem","_nextPrevious","forEachAddedItem","_nextAdded","forEachMovedItem","_nextMoved","forEachRemovedItem","forEachIdentityChange","_nextIdentityChange","diff","collection","check","_reset","itemTrackBy","mayBeDirty","index_1","trackById","_verifyReinsertion","_addIdentityChange","_mismatch","iterateListLike","_truncate","isDirty","nextRecord","previousRecord","_prev","_remove","_moveAfter","_reinsertAfter","_addAfter","IterableChangeRecord_","reinsertRecord","_addToMoves","_addToRemovals","_unlink","prevRecord","prev","_prevRemoved","_insertAfter","_DuplicateMap","put","toIndex","_prevDup","_nextDup","_DuplicateItemRecordList","_head","_tail","atOrAfterIndex","duplicates","recordList","moveOffset","MissingTranslationStrategy","DefaultKeyValueDifferFactory","DefaultKeyValueDiffer","_mapHead","_appendAfter","_previousMapHead","_changesHead","_changesTail","forEachChangedItem","_nextChanged","_forEach","_maybeAddToChanges","_getOrCreateRecordForKey","_insertBeforeOrAppend","before","record_1","KeyValueChangeRecord_","_addToAdditions","newValue","_addToChanges","IterableDiffers","copied","extend","iterable","getTypeNameForDebugging","KeyValueDiffers","kv","keyValDiff","iterableDiff","defaultIterableDiffers","defaultKeyValueDiffers","platformCore","LOCALE_ID","TRANSLATIONS","TRANSLATIONS_FORMAT","_iterableDiffersFactory","_keyValueDiffersFactory","_localeFactory","locale","ApplicationModule","InertBodyHelper","defaultDoc","inertDocument","implementation","createHTMLDocument","inertBodyElement","body","inertHtml","createElement","appendChild","innerHTML","querySelector","getInertBodyElement","isDOMParserAvailable","DOMParser","getInertBodyElement_DOMParser","getInertBodyElement_InertDocument","getInertBodyElement_XHR","html","encodeURI","XMLHttpRequest","responseType","open","send","response","parseFromString","templateEl","documentMode","stripCustomNsAttrs","elAttrs","attrName","removeAttribute","childNode","firstChild","nodeType","Node","ELEMENT_NODE","nextSibling","SAFE_URL_PATTERN","DATA_URL_PATTERN","_sanitizeUrl","url","match","tagSet","tags","e_1","_c","e_1_1","return","merge$1","sets","e_2","sets_1","sets_1_1","e_2_1","inertBodyHelper","VOID_ELEMENTS","OPTIONAL_END_TAG_BLOCK_ELEMENTS","OPTIONAL_END_TAG_INLINE_ELEMENTS","OPTIONAL_END_TAG_ELEMENTS","BLOCK_ELEMENTS","INLINE_ELEMENTS","VALID_ELEMENTS","URI_ATTRS","SRCSET_ATTRS","HTML_ATTRS","VALID_ATTRS","SanitizingHtmlSerializer","sanitizedSomething","buf","sanitizeChildren","startElement","TEXT_NODE","chars","endElement","checkClobberedElement","tagName","nodeName","toLowerCase","srcset","elAttr","lower","trim","encodeEntities","nextNode","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","outerHTML","SURROGATE_PAIR_REGEXP","NON_ALPHANUMERIC_REGEXP","charCodeAt","_sanitizeHtml","unsafeHtmlInput","unsafeHtml","mXSSAttempts","parsedHtml","sanitizer","safeHtml","getTemplateContent","parent_1","isTemplateElement","content","SecurityContext","SAFE_STYLE_VALUE","RegExp","URL_RE","_sanitizeStyle","urlMatch","hasBalancedQuotes","outsideSingle","outsideDouble","Sanitizer","shiftInitState","priorInitState","newInitState","state","initState","initIndex","shouldCallLifecycleInitHook","asTextData","nodes","asElementData","asProviderData","asPureExpressionData","asQueryList","DebugContext","Services","setCurrentNode","createRootView","createEmbeddedView","createComponentView","createNgModuleRef","overrideProvider","overrideComponentView","clearOverrides","checkAndUpdateView","checkNoChangesView","destroyView","resolveDep","createDebugContext","handleEvent","updateDirectives","updateRenderer","dirtyParentQueries","expressionChangedAfterItHasBeenCheckedError","oldValue","currValue","isFirstCheck","viewDebugError","_addDebugContext","logError","viewDestroyedError","NOOP","_tokenKeyCache","tokenKey","UNDEFINED_RENDERER_TYPE_ID","EMPTY_RENDERER_TYPE_ID","_renderCompCount","resolveRendererType2","isFilled","None","checkBinding","bindingIdx","oldValues","bindingIndex","checkAndUpdateBinding","checkBindingNoChanges","bindingName","bindings","nodeIndex","markParentViewsForCheck","currView","viewContainerParent","markParentViewsForCheckProjectedViews","endView","dispatchEvent","event","componentView","root","declaredViewContainer","parentNodeDef","viewParentEl","renderNode","renderElement","renderText","elementEventFullName","isComponentView","isEmbeddedView","filterQueryId","queryId","splitMatchedQueriesDsl","matchedQueriesDsl","matchedQueries","matchedQueryIds","valueType","splitDepsDsl","sourceName","getParentRenderElement","renderHost","renderParent","componentRendererType","Native","DEFINITION_CACHE","WeakMap","resolveDefinition","visitRootRenderNodes","renderer","visitSiblingRenderNodes","startIndex","endIndex","nodeDef","visitRenderNode","childCount","visitProjectedRenderNodes","ngContentIndex","compView","hostElDef","projectedNodes","execRenderNodeAction","ngContent","rn","bindingFlags","embeddedViews","viewContainer","_embeddedViews","NS_PREFIX_RE","splitNamespace","calcBindingFlags","_toStringWithNull","elDef","selectorOrNode","ns","createComment","parentEl","selectRootElement","attrs","setAttribute","listenToElementOutputs","output","handleEventClosure","renderEventHandlerClosure","listenTarget","listenerView","disposable","listen","disposables","outputIndex","checkAndUpdateElementValue","binding","elData","renderNode$$1","setElementAttribute","securityContext","renderValue","sanitize","setElementClass","addClass","removeClass","setElementStyle","STYLE","unit","suffix","setStyle","removeStyle","setElementProperty","setProperty","UNDEFINED_VALUE","InjectorRefTokenKey$1","INJECTORRefTokenKey$1","NgModuleRefTokenKey","resolveNgModuleDep","depDef","tokenKey_1","providerDef","_def","providersByKey","providerInstance","_createProviderInstance$1","targetsModule","moduleTransitivelyPresent","modules","isRoot","injectable","_createClass","depValues","_callFactory","detachEmbeddedView","elementData","viewIndex","removeFromArray","renderDetachView","renderAttachEmbeddedView","prevView","prevRenderNode","addToArray","arr","EMPTY_CONTEXT","getComponentViewDefinitionFactory","viewDefFactory","ComponentFactory_","_inputs","_outputs","inputsArr","templateName","outputsArr","viewDef","componentNodeIndex","componentProvider","ComponentRef_","ViewRef_","_view","_viewRef","_component","_elDef","changeDetectorRef","Injector_","createViewContainerData","ViewContainerRef_","_data","ref","attachToViewContainerRef","templateRef","insert","createComponent","ngModuleRef","contextInjector","parentInjector","viewRef_","attachEmbeddedView","parentView","attachProjectedView","vcElementData","dvcElementData","projectedViews","template","_projectedViews","markNodeAsProjectedTemplate","nodeFlags","childFlags","move","moveEmbeddedView","oldViewIndex","newViewIndex","viewData","detach","createChangeDetectorRef","_viewContainerRef","_appRef","rootRenderNodes","renderNodes","markForCheck","fs","rendererFactory","begin","end","reattach","vcRef","createTemplateData","TemplateRef_","_parentView","createInjector$1","createRendererV1","RendererAdapter","namespaceAndName","createViewRoot","hostElement","createTemplateAnchor","parentElement","comment","createText","projectNodes","attachViewAfter","viewRootNodes","viewAllNodes","destroyNode","listenGlobal","propertyName","propertyValue","attributeValue","setBindingDebugInfo","className","isAdd","styleName","styleValue","invokeElementMethod","methodName","setText","setValue","animate","bootstrapComponents","NgModuleRef_","_moduleType","initNgModule","provDef","injectFlags","callNgModuleLifecycle","lifecycles","RendererV1TokenKey","Renderer2TokenKey","ElementRefTokenKey","ViewContainerRefTokenKey","TemplateRefTokenKey","ChangeDetectorRefTokenKey","InjectorRefTokenKey","INJECTORRefTokenKey","checkIndex","depDefs","directChildFlags","childMatchedQueries","createProviderInstance","_createProviderInstance","createPipeInstance","createClass","createDirectiveInstance","subscription","eventHandlerClosure","allowPrivateServices","callFactory","ViewAction","NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR","startView","tokenKey$$1","searchView","findCompView","providerDef_1","allProviders","publicProviders","providerData","updateProp","nonMinifiedName","callLifecycleHooksChildrenFirst","callProviderLifecycles","callElementProvidersLifecycles","ngAfterContentInit","ngAfterContentChecked","ngAfterViewInit","ngAfterViewChecked","queryIds","nodeMatchedQueries","tplDef","filterId","checkAndUpdateQuery","queryList","directiveInstance","newValues","elementDef","calcQueryValues","notify","boundValue","bindingType","queryDef","getQueryValue","embeddedView","dvc","projectedView","queryValueType","appendNgContent","_pureExpressionDef","propertyNames","prefix","_addInterpolationPart","isNgContainer","validateNode","nodeCount","lastRenderRootNode","parentEnd","anchorDef$$1","createView","initView","createViewNodes","compRenderer","rendererType","createRenderer","outputCount","bindingCount","nodeData","compViewDef","execComponentViewsAction","CreateViewNodes","execQueriesAction","markProjectedViewsForCheck","execEmbeddedViewsAction","CheckNoChanges","CheckAndUpdate","callInit","checkAndUpdateNode","argStyle","v0","v1","v2","v3","v4","v5","v6","v7","v8","v9","checkAndUpdateNodeInline","checkAndUpdateElementInline","bindLen","changed","checkAndUpdateTextInline","checkAndUpdateDirectiveInline","directive","ngOnChanges","ngOnInit","ngDoCheck","checkAndUpdatePureExpressionInline","transform","checkAndUpdateNodeDynamic","checkAndUpdateElementDynamic","checkAndUpdateTextDynamic","checkAndUpdateDirectiveDynamic","checkAndUpdatePureExpressionDynamic","i_1","checkNoChangesNode","checkNoChangesNodeInline","checkNoChangesNodeDynamic","checkNoChangesQuery","Destroy","detachProjectedView","destroyViewNodes","callViewAction","viewState","execProjectedViewsAction","CheckNoChangesProjectedViews","CheckAndUpdateProjectedViews","queryFlags","staticDynamicQueryFlag","checkType","initServicesIfNeeded","services","createDebugServices","debugSetCurrentNode","debugCreateRootView","debugCreateEmbeddedView","debugCreateComponentView","debugCreateNgModuleRef","debugOverrideProvider","debugOverrideComponentView","debugClearOverrides","debugCheckAndUpdateView","debugCheckNoChangesView","debugDestroyView","DebugContext_","debugHandleEvent","debugUpdateDirectives","debugUpdateRenderer","createProdServices","createProdRootView","prodCheckAndUpdateNode","prodCheckNoChangesNode","elInjector","createRootData","DebugRendererFactory2","defWithOverride","applyProviderOverridesToView","callWithDebugContext","DebugAction","anchorDef","viewDef$$1","viewDefOverrides","applyProviderOverridesToNgModule","calcHasOverrides","hasOverrides","hasDeprecatedOverrides","providerOverrides","override","deprecatedBehavior","providerOverridesWithScope","applyProviderOverrides","moduleSet_1","_currentAction","_currentView","_currentNodeIndex","comp","compFactory","elementIndicesWithOverwrittenProviders","findElementIndicesWithOverwrittenProviders","elIndicesWithOverwrittenProviders","lastElementDef","applyProviderOverridesToElement","elIndex","nextDirectiveWithBinding","debugCheckDirectivesFn","debugCheckAndUpdateNode","debugCheckNoChangesNode","nextRenderNodeWithBinding","debugCheckRenderNodeFn","givenValues","bindingValues","camelCaseToDashCase","CAMEL_CASE_REGEXP","normalizeDebugBindingValue","attr","elView","elOrCompView","childDef","collectReferences","findHostElement","logViewDef","logNodeIndex","renderNodeIndex","getRenderNodeIndex","currRenderNodeIndex","refName","oldAction","oldView","oldNodeIndex","isViewDebugError","viewWrappedDebugError","getCurrentDebugContext","renderData","DebugRenderer2","whenRenderingDone","removeDebugNodeFromIndex","namespace","debugCtx","debugEl","debugChildEl","debugRefEl","oldChild","style","NgModuleFactory_","_ngModuleDefFactory","queueContentHooks","tView","afterContentInit","contentHooks","afterContentChecked","contentCheckHooks","queueViewHooks","afterViewInit","viewHooks","afterViewChecked","viewCheckHooks","queueDestroyHooks","destroyHooks","executeInitHooks","currentView","creationMode","lifecycleStage","executeHooks","initHooks","checkHooks","allHooks","hooksToCall","callHooks","RendererStyleFlags3","NG_PROJECT_AS_ATTR_NAME","isProceduralRenderer","domRendererFactory3","document","isDifferent","stringify$1","findNextRNodeSibling","stopNode","currentNode","pNextOrParent","findFirstRNode","currentSibling","parentType","getNextLNodeWithProjection","getNextOrParentSiblingNode","initialNode","rootNode","native","childContainerData","dynamicLContainerNode","views","head","createTextNode","addRemoveViewFromContainer","container","insertMode","beforeNode","insertView","newView","setViewNext","containerNextNativeNode","removeView","removeIndex","viewNode","destroyViewTree","rootView","viewOrContainer","cleanUpView","getParentState","queries","removeListeners","cleanup","removeEventListener","executeOnDestroys","executePipeOnDestroys","pipeDestroyHooks","canInsertNativeNode","appendProjectedNode","currentParent","lContainer","isNodeMatchingSelector","tNode","nodeClassAttrVal","cssClassToMatch","nodeClassesLen","matchIndex","matchEndIdx","mode","nodeAttrs","skipToNextSelector","isPositive","attrIndexInNode","findAttrIndexInNode","selectorAttrValue","nodeAttrValue","isNodeMatchingSelectorList","matchingSelectorIndex","selectors","textSelectors","ngProjectAsAttrVal","getProjectAsAttrValue","ngProjectAsAttrIdx","throwMultipleComponentError","throwErrorIfNoChangesMode","checkNoChangesMode","previousOrParentNode","isParent","tData","NG_HOST_SYMBOL","_CLEAN_PROMISE","_ROOT_DIRECTIVE_INDICES","CIRCULAR$2","getPreviousOrParentNode","currentQueries","directives","getCreationMode","firstTemplatePass","enterView","host","bindingStartIndex","leaveView","refreshDirectives","executeInitAndContentHooks","setHostBindings","hostBindings","refreshChildComponents","componentRefresh","defs","dirIndex","createLView","viewId","tail","dynamicViewCount","createLNodeObject","nodeInjector","createLNode","isState","renderEmbeddedTemplate","pipes","_isParent","_previousOrParentNode","rf","getOrCreateTView","refreshDynamicChildren","getRenderFlags","createDirectivesAndLocals","localRefs","containerData","createTNode","cacheMatchingDirectivesForNode","exportsMap","","currentMatches","findDirectiveMatches","directiveRegistry","diPublic","valueIndex","resolveDirective","saveNameToExportMap","cacheMatchingLocalNames","localNames","instantiateDirectivesDirectly","count","start","tDirectives","directiveCreate","saveResolvedLocalsInData","throwCyclicDependencyError","initChangeDetectorIfExisting","_setComponentContext","exportAs","ngPrivateData","createTView","pipeRegistry","setUpAttributes","isProc","attrVal","locateHostElement","elementOrSelector","defaultRenderer","initialInputs","generatePropertyAliases","tNodeFlags","direction","propStore","isInput","directiveDef","propertyAliasMap","publicName","internalName","baseDirectiveCreate","addComponentLogic","directiveDefs","pipeDefs","addToViewTree","onPush","queueComponentIndexForCheck","queueInitHooks","onInit","doCheck","queueHostBindingForCheck","setInputsFromAttrs","directiveIndex","initialInputData","generateInitialInputs","minifiedInputName","createLContainer","parentLNode","nextIndex","container_1","elementIndex","viewAttached","detectChangesInternal","getDirectiveInstance","appendToProjectionNode","projectionNode","appendedFirst","appendedLast","projectionNodeData","findComponentHost","lView","viewRootLNode","markViewDirty","scheduleTick","rootContext","res_1","clean","scheduler","getRootView","rootComponent","renderComponentOrTemplate","componentOrContext","_getComponentHostLElementNode","hostNode","NO_CHANGE","initBindings","store","consumeBinding","bindingUpdated","checkAndUpdateBinding$1","bindingUpdated2","exp1","exp2","different","bindingUpdated4","exp3","exp4","getTView","instanceOrArray","CLEAN_PROMISE","ROOT_DIRECTIVE_INDICES","ViewRef$1","EmbeddedViewRef$1","_lViewNode","createViewRef","addDestroyable","destroyFn","NG_ELEMENT_ID","BLOOM_SIZE","nextNgElementId","getOrCreateNodeInjector","getOrCreateNodeInjectorForNode","bf0","bf1","bf2","bf3","bf4","bf5","bf6","bf7","cbf0","cbf1","cbf2","cbf3","cbf4","cbf5","cbf6","cbf7","viewContainerRef","elementRef","diPublicInInjector","di","bloomAdd","bloomBit","mask","getOrCreateChangeDetectorRef","isComponent","getOrCreateHostChangeDetector","getClosestComponentAncestor","hostInjector","getOrCreateInjectable","bloomHash","bloomHashBit","formerInjector","bloomFindPossibleInjector","flags_1","searchMatchesQueuedForCreation","startInjector","ReadFromInjectorFn","read","ElementRef$1","getOrCreateContainerRef","vcRefHost","lContainerNode","ViewContainerRef$1","_lContainerNode","_viewRefs","notImplemented","lViewNode","adjustedIdx","_adjustIndex","newIndex","shift","getOrCreateTemplateRef","TemplateRef$1","getOrCreateElementRef","getRenderer","_renderer","_directives","_pipes","_template","defineComponent","componentDefinition","pipeTypes","directiveTypes","invertObject","OnPush","extractDirectiveDef","extractPipeDef","feature","features","ngComponentDef","ngDirectiveDef","ngPipeDef","PRIVATE_PREFIX","EMPTY$1","newObj","minifiedKey","defineDirective","pureFunction1","pureFn","exp","thisArg","pureFunction2","pureFunction3","pureFunction4","pureFunctionV","exps","isPure","LQueries_","deep","shallow","track","descend","createQuery$1","containerValues","clonedQuery","viewValues","addNode","getIdxOfMatchingSelector","getIdxOfMatchingDirective","readFromNodeInjector","directiveIdx","matchingIdx","addMatch","matchingValue","previous","createPredicate","_valuesTree","QueryList$1","QueryList_","_values","flatten$1","BRAND","bypassSanitizationTrustString","trustedString","trusted","ɵangular_packages_core_core_j","ɵangular_packages_core_core_k","ɵangular_packages_core_core_l","ɵangular_packages_core_core_f","ɵangular_packages_core_core_g","ɵangular_packages_core_core_h","ɵangular_packages_core_core_i","ɵangular_packages_core_core_c","ɵangular_packages_core_core_d","ɵangular_packages_core_core_e","ɵangular_packages_core_core_m","ɵangular_packages_core_core_o","ɵangular_packages_core_core_n","ɵangular_packages_core_core_r","ɵangular_packages_core_core_p","ɵangular_packages_core_core_q","ɵangular_packages_core_core_v","ɵangular_packages_core_core_x","ɵangular_packages_core_core_w","ɵangular_packages_core_core_u","ɵangular_packages_core_core_y","ɵangular_packages_core_core_bb","ɵangular_packages_core_core_bd","ɵangular_packages_core_core_be","ɵangular_packages_core_core_bc","ɵangular_packages_core_core_ba","ɵangular_packages_core_core_z","ɵangular_packages_core_core_a","ɵangular_packages_core_core_b","ɵangular_packages_core_core_s","ɵangular_packages_core_core_t","destroyPlatform","enableProdMode","asNativeElements","debugEls","setTestabilityGetter","CUSTOM_ELEMENTS_SCHEMA","NO_ERRORS_SCHEMA","createInjector","getModuleFactory","ɵALLOW_MULTIPLE_PLATFORMS","ɵAPP_ID_RANDOM_PROVIDER","ɵdefaultIterableDiffers","ɵdevModeEqual","ɵisListLikeIterable","ɵisDefaultChangeDetectionStrategy","isDefaultChangeDetectionStrategy","changeDetectionStrategy","ɵConsole","ɵinject","ɵsetCurrentInjector","ɵAPP_ROOT","ɵComponentFactory","ɵCodegenComponentFactoryResolver","ɵReflectionCapabilities","ɵRenderDebugInfo","ɵ_sanitizeHtml","ɵ_sanitizeStyle","ɵ_sanitizeUrl","ɵglobal","ɵlooseIdentical","ɵstringify","ɵmakeDecorator","ɵisObservable","isObservable","ɵisPromise","ɵclearOverrides","ɵoverrideComponentView","ɵoverrideProvider","ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR","ɵdefineComponent","ɵdefineDirective","ɵdefinePipe","definePipe","pipeDef","ɵdetectChanges","ɵrenderComponent","renderComponent","componentDef","componentTag","requestAnimationFrame","elementNode","tag","rNode","resetApplicationState","hostFeatures","ɵdirectiveInject","directiveInject","ɵinjectTemplateRef","injectTemplateRef","ɵinjectViewContainerRef","injectViewContainerRef","ɵinjectChangeDetectorRef","injectChangeDetectorRef","ɵinjectAttribute","injectAttribute","ɵPublicFeature","PublicFeature","definition","ɵNgOnChangesFeature","NgOnChangesFeature","inputPropertyNames","proto","writable","_loop_1","pubKey","minKey","privateMinKey","existingDesc","getOwnPropertyDescriptor","simpleChanges","onChangesWrapper","delegateHook","ɵmarkDirty","markDirty","ɵNC","ɵC","ɵE","elementStart","ɵL","listenerFn","useCapture","cleanupFns","wrappedListener","wrapListenerWithDirtyLogic","cleanupFn","wrapListenerWithDirtyAndDefault","wrapListenerIn_markViewDirty","preventDefault","addEventListener","outputData","createOutput","ɵT","textNode","ɵV","embeddedViewStart","viewBlockId","scanForView","containerNode","startIdx","viewAtPositionId","getOrCreateEmbeddedTView","tContainer","ɵQ","memoryIndex","getCurrentQueries","QueryType","ɵd","loadDirective","ɵP","projection","localIndex","selectorIndex","nodesForSelector","nodeToProject","previouslyProjected","lastNodeToProject","ɵb","ɵi1","interpolation1","ɵi2","interpolation2","i0","ɵi3","interpolation3","i1","ɵi4","interpolation4","i2","ɵi5","interpolation5","i3","ɵi6","interpolation6","i4","ɵi7","interpolation7","i5","ɵi8","interpolation8","i6","ɵiV","interpolationV","ɵpb1","pipeBind1","pipeInstance","ɵpb2","pipeBind2","ɵpb3","pipeBind3","ɵpb4","pipeBind4","ɵpbV","pipeBindV","ɵf0","pureFunction0","ɵf1","ɵf2","ɵf3","ɵf4","ɵf5","pureFunction5","exp5","ɵf6","pureFunction6","exp6","ɵf7","pureFunction7","exp7","ɵf8","pureFunction8","exp8","ɵfV","ɵcR","containerRefreshStart","ɵcr","containerRefreshEnd","ɵqR","queryRefresh","ɵe","elementEnd","queueLifecycleHooks","ɵp","elementProperty","dataValue","inputData","setInputsForProperty","markDirtyIfOnPush","ɵpD","projectionDef","noOfNodeBuckets","distributedNodes","componentChild","ɵa","elementAttribute","strValue","ɵs","elementStyle","lElement","removeProperty","ɵsn","elementStyleNamed","suffixOrSanitizer","DashCase","ɵk","elementClass","ɵkn","elementClassNamed","classList","ɵt","textBinding","existingNode","textContent","insertChild","nativeSibling","ɵv","embeddedViewEnd","setRenderParentInProjectedNodes","ɵst","ɵld","ɵPp","pipeName","getPipeDef","ɵwhenRendered","whenRendered","getRootContext","ɵbypassSanitizationTrustHtml","bypassSanitizationTrustHtml","trustedHtml","ɵbypassSanitizationTrustStyle","bypassSanitizationTrustStyle","trustedStyle","ɵbypassSanitizationTrustScript","bypassSanitizationTrustScript","trustedScript","ɵbypassSanitizationTrustUrl","bypassSanitizationTrustUrl","trustedUrl","ɵbypassSanitizationTrustResourceUrl","bypassSanitizationTrustResourceUrl","trustedResourceUrl","ɵsanitizeHtml","sanitizeHtml","ɵsanitizeStyle","sanitizeStyle","unsafeStyle","ɵsanitizeUrl","sanitizeUrl","unsafeUrl","ɵsanitizeResourceUrl","sanitizeResourceUrl","unsafeResourceUrl","ɵregisterModuleFactory","registerModuleFactory","ɵEMPTY_ARRAY","ɵEMPTY_MAP","ɵand","templateFactory","ɵccf","createComponentFactory","ɵcmf","createNgModuleFactory","ngModuleType","defFactory","ɵcrt","createRendererType2","ɵdid","outputDefs","ɵeld","fixedAttrs","bindingDefs","suffixOrSecurityContext","_d","ns_1","name_1","_e","ɵelementEventFullName","ɵgetComponentViewDefinitionFactory","ɵinlineInterpolate","inlineInterpolate","valueCount","c0","a1","c1","a2","c2","a3","c3","a4","c4","a5","c5","a6","c6","a7","c7","a8","c8","a9","c9","ɵinterpolate","interpolate","constAndInterp","ɵmod","moduleDef","ɵmpd","moduleProvideDef","ɵncd","ngContentDef","ɵnov","nodeValue","ɵpid","ɵprd","ɵpad","pureArrayDef","argCount","ɵpod","pureObjectDef","propToIndex","nbKeys","ɵppd","purePipeDef","ɵqud","ɵted","textDef","staticText","ɵunv","unwrapValue","nodeIdx","globalBindingIdx","ɵvid","viewBindingCount","viewDisposableCount","viewNodeFlags","viewRootNodeFlags","viewMatchedQueries","currentRenderParent","currentElementHasPublicProviders","currentElementHasPrivateProviders","newParent","rootNodeFlags"],"mappings":"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","sourcesContent":["/**\n * @license Angular v6.0.3\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n */\n\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('rxjs/operators')) :\n\ttypeof define === 'function' && define.amd ? define('@angular/core', ['exports', 'rxjs', 'rxjs/operators'], factory) :\n\t(factory((global.ng = global.ng || {}, global.ng.core = {}),global.rxjs,global.rxjs.operators));\n}(this, (function (exports,rxjs,operators) { 'use strict';\n\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\nfunction __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\nvar __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\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\nfunction __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\nfunction __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\nfunction __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}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Construct an `InjectableDef` which defines how a token will be constructed by the DI system, and\n * in which injectors (if any) it will be available.\n *\n * This should be assigned to a static `ngInjectableDef` field on a type, which will then be an\n * `InjectableType`.\n *\n * Options:\n * * `providedIn` determines which injectors will include the injectable, by either associating it\n *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be\n *   provided in the `'root'` injector, which will be the application-level injector in most apps.\n * * `factory` gives the zero argument function which will create an instance of the injectable.\n *   The factory can call `inject` to access the `Injector` and request injection of dependencies.\n *\n * @experimental\n */\nfunction defineInjectable(opts) {\n    return {\n        providedIn: opts.providedIn || null, factory: opts.factory, value: undefined,\n    };\n}\n/**\n * Construct an `InjectorDef` which configures an injector.\n *\n * This should be assigned to a static `ngInjectorDef` field on a type, which will then be an\n * `InjectorType`.\n *\n * Options:\n *\n * * `factory`: an `InjectorType` is an instantiable type, so a zero argument `factory` function to\n *   create the type must be provided. If that factory function needs to inject arguments, it can\n *   use the `inject` function.\n * * `providers`: an optional array of providers to add to the injector. Each provider must\n *   either have a factory or point to a type which has an `ngInjectableDef` static property (the\n *   type must be an `InjectableType`).\n * * `imports`: an optional array of imports of other `InjectorType`s or `InjectorTypeWithModule`s\n *   whose providers will also be added to the injector. Locally provided types will override\n *   providers from imports.\n *\n * @experimental\n */\nfunction defineInjector(options) {\n    return {\n        factory: options.factory, providers: options.providers || [], imports: options.imports || [],\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 * 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 * When creating an `InjectionToken`, you can optionally specify a factory function which returns\n * (possibly by creating) a default value of the parameterized type `T`. This sets up the\n * `InjectionToken` using this factory as a provider as if it was defined explicitly in the\n * application's root injector. If the factory function, which takes zero arguments, needs to inject\n * dependencies, it can do so using the `inject` function. See below for an example.\n *\n * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which\n * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As\n * mentioned above, `'root'` is the default value for `providedIn`.\n *\n * ### Example\n *\n * #### Tree-shakeable InjectionToken\n *\n * {@example core/di/ts/injector_spec.ts region='ShakeableInjectionToken'}\n *\n * #### Plain InjectionToken\n *\n * {@example core/di/ts/injector_spec.ts region='InjectionToken'}\n *\n *\n */\nvar InjectionToken = /** @class */ (function () {\n    function InjectionToken(_desc, options) {\n        this._desc = _desc;\n        /** @internal */\n        this.ngMetadataName = 'InjectionToken';\n        if (options !== undefined) {\n            this.ngInjectableDef = defineInjectable({\n                providedIn: options.providedIn || 'root',\n                factory: options.factory,\n            });\n        }\n        else {\n            this.ngInjectableDef = undefined;\n        }\n    }\n    InjectionToken.prototype.toString = function () { return \"InjectionToken \" + this._desc; };\n    return InjectionToken;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ANNOTATIONS = '__annotations__';\nvar PARAMETERS = '__parameters__';\nvar PROP_METADATA = '__prop__metadata__';\n/**\n * @suppress {globalThis}\n */\nfunction makeDecorator(name, props, parentClass, chainFn, typeFn) {\n    var metaCtor = makeMetadataCtor(props);\n    function DecoratorFactory() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (this instanceof DecoratorFactory) {\n            metaCtor.call.apply(metaCtor, __spread([this], args));\n            return this;\n        }\n        var annotationInstance = new ((_a = DecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n        var TypeDecorator = function TypeDecorator(cls) {\n            typeFn && typeFn.apply(void 0, __spread([cls], args));\n            // Use of Object.defineProperty is important since it creates non-enumerable property which\n            // prevents the property is copied during subclassing.\n            var annotations = cls.hasOwnProperty(ANNOTATIONS) ?\n                cls[ANNOTATIONS] :\n                Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];\n            annotations.push(annotationInstance);\n            return cls;\n        };\n        if (chainFn)\n            chainFn(TypeDecorator);\n        return TypeDecorator;\n        var _a;\n    }\n    if (parentClass) {\n        DecoratorFactory.prototype = Object.create(parentClass.prototype);\n    }\n    DecoratorFactory.prototype.ngMetadataName = name;\n    DecoratorFactory.annotationCls = DecoratorFactory;\n    return DecoratorFactory;\n}\nfunction makeMetadataCtor(props) {\n    return function ctor() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (props) {\n            var values = props.apply(void 0, __spread(args));\n            for (var propName in values) {\n                this[propName] = values[propName];\n            }\n        }\n    };\n}\nfunction makeParamDecorator(name, props, parentClass) {\n    var metaCtor = makeMetadataCtor(props);\n    function ParamDecoratorFactory() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (this instanceof ParamDecoratorFactory) {\n            metaCtor.apply(this, args);\n            return this;\n        }\n        var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n        ParamDecorator.annotation = annotationInstance;\n        return ParamDecorator;\n        function ParamDecorator(cls, unusedKey, index) {\n            // Use of Object.defineProperty is important since it creates non-enumerable property which\n            // prevents the property is copied during subclassing.\n            var parameters = cls.hasOwnProperty(PARAMETERS) ?\n                cls[PARAMETERS] :\n                Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];\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            (parameters[index] = parameters[index] || []).push(annotationInstance);\n            return cls;\n        }\n        var _a;\n    }\n    if (parentClass) {\n        ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);\n    }\n    ParamDecoratorFactory.prototype.ngMetadataName = name;\n    ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;\n    return ParamDecoratorFactory;\n}\nfunction makePropDecorator(name, props, parentClass) {\n    var metaCtor = makeMetadataCtor(props);\n    function PropDecoratorFactory() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (this instanceof PropDecoratorFactory) {\n            metaCtor.apply(this, args);\n            return this;\n        }\n        var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n        return function PropDecorator(target, name) {\n            var constructor = target.constructor;\n            // Use of Object.defineProperty is important since it creates non-enumerable property which\n            // prevents the property is copied during subclassing.\n            var meta = constructor.hasOwnProperty(PROP_METADATA) ?\n                constructor[PROP_METADATA] :\n                Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];\n            meta[name] = meta.hasOwnProperty(name) && meta[name] || [];\n            meta[name].unshift(decoratorInstance);\n        };\n        var _a;\n    }\n    if (parentClass) {\n        PropDecoratorFactory.prototype = Object.create(parentClass.prototype);\n    }\n    PropDecoratorFactory.prototype.ngMetadataName = name;\n    PropDecoratorFactory.annotationCls = PropDecoratorFactory;\n    return PropDecoratorFactory;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This token can be used to create a virtual provider that will populate the\n * `entryComponents` fields of components and ng modules based on its `useValue`.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) will be added to the `entryComponents` property.\n *\n * ### Example\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on the router configuration which refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n *   return [\n *     {provide: ROUTES, useValue: routes},\n *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n *   ];\n * }\n *\n * // user code\n * let routes = [\n *   {path: '/root', component: RootComp},\n *   {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n *   providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @experimental\n */\nvar ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');\n/**\n * Attribute decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Attribute = makeParamDecorator('Attribute', function (attributeName) { return ({ attributeName: attributeName }); });\n/**\n * Base class for query metadata.\n *\n * See {@link ContentChildren}, {@link ContentChild}, {@link ViewChildren}, {@link ViewChild} for\n * more information.\n *\n *\n */\nvar Query = /** @class */ (function () {\n    function Query() {\n    }\n    return Query;\n}());\n/**\n * ContentChildren decorator and metadata.\n *\n *\n *  @Annotation\n */\nvar ContentChildren = makePropDecorator('ContentChildren', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: false, isViewQuery: false, descendants: false }, data));\n}, Query);\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n */\nvar ContentChild = makePropDecorator('ContentChild', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: true, isViewQuery: false, descendants: true }, data));\n}, Query);\n/**\n * ViewChildren decorator and metadata.\n *\n *\n * @Annotation\n */\nvar ViewChildren = makePropDecorator('ViewChildren', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: false, isViewQuery: true, descendants: true }, data));\n}, Query);\n/**\n * ViewChild decorator and metadata.\n *\n *\n * @Annotation\n */\nvar ViewChild = makePropDecorator('ViewChild', function (selector, data) {\n    return (__assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data));\n}, Query);\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 * @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 * Describes within the change detector which strategy will be used the next time change\n * detection is triggered.\n *\n */\n/**\n * Describes within the change detector which strategy will be used the next time change\n * detection is triggered.\n *\n */\n\n/**\n * Describes within the change detector which strategy will be used the next time change\n * detection is triggered.\n *\n */\n(function (ChangeDetectionStrategy) {\n    /**\n     * `OnPush` means that the change detector's mode will be initially set to `CheckOnce`.\n     */\n    ChangeDetectionStrategy[ChangeDetectionStrategy[\"OnPush\"] = 0] = \"OnPush\";\n    /**\n     * `Default` means that the change detector's mode will be initially set to `CheckAlways`.\n     */\n    ChangeDetectionStrategy[ChangeDetectionStrategy[\"Default\"] = 1] = \"Default\";\n})(exports.ChangeDetectionStrategy || (exports.ChangeDetectionStrategy = {}));\n/**\n * Describes the status of the detector.\n */\n/**\n * Describes the status of the detector.\n */\n\n/**\n * Describes the status of the detector.\n */\n(function (ChangeDetectorStatus) {\n    /**\n     * `CheckOnce` means that after calling detectChanges the mode of the change detector\n     * will become `Checked`.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"CheckOnce\"] = 0] = \"CheckOnce\";\n    /**\n     * `Checked` means that the change detector should be skipped until its mode changes to\n     * `CheckOnce`.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Checked\"] = 1] = \"Checked\";\n    /**\n     * `CheckAlways` means that after calling detectChanges the mode of the change detector\n     * will remain `CheckAlways`.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"CheckAlways\"] = 2] = \"CheckAlways\";\n    /**\n     * `Detached` means that the change detector sub tree is not a part of the main tree and\n     * should be skipped.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Detached\"] = 3] = \"Detached\";\n    /**\n     * `Errored` means that the change detector encountered an error checking a binding\n     * or calling a directive lifecycle method and is now in an inconsistent state. Change\n     * detectors in this state will no longer detect changes.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Errored\"] = 4] = \"Errored\";\n    /**\n     * `Destroyed` means that the change detector is destroyed.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Destroyed\"] = 5] = \"Destroyed\";\n})(exports.ɵChangeDetectorStatus || (exports.ɵChangeDetectorStatus = {}));\nfunction isDefaultChangeDetectionStrategy(changeDetectionStrategy) {\n    return changeDetectionStrategy == null ||\n        changeDetectionStrategy === exports.ChangeDetectionStrategy.Default;\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 * Directive decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Directive = makeDecorator('Directive', function (dir) {\n    if (dir === void 0) { dir = {}; }\n    return dir;\n});\n/**\n * Component decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Component = makeDecorator('Component', function (c) {\n    if (c === void 0) { c = {}; }\n    return (__assign({ changeDetection: exports.ChangeDetectionStrategy.Default }, c));\n}, Directive);\n/**\n * Pipe decorator and metadata.\n *\n * Use the `@Pipe` annotation to declare that a given class is a pipe. A pipe\n * class must also implement {@link PipeTransform} interface.\n *\n * To use the pipe include a reference to the pipe class in\n * {@link NgModule#declarations}.\n *\n *\n * @Annotation\n */\nvar Pipe = makeDecorator('Pipe', function (p) { return (__assign({ pure: true }, p)); });\n/**\n * Input decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Input = makePropDecorator('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });\n/**\n * Output decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Output = makePropDecorator('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });\n/**\n * HostBinding decorator and metadata.\n *\n *\n * @Annotation\n */\nvar HostBinding = makePropDecorator('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); });\n/**\n * HostListener decorator and metadata.\n *\n *\n * @Annotation\n */\nvar HostListener = makePropDecorator('HostListener', function (eventName, args) { return ({ eventName: eventName, args: args }); });\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Represents a type that a Component or other object is instances of.\n *\n * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by\n * the `MyCustomComponent` constructor function.\n *\n *\n */\nvar Type = Function;\nfunction isType(v) {\n    return typeof v === 'function';\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\nvar _global = __window || __global || __self;\nvar promise = Promise.resolve(0);\nvar _symbolIterator = null;\nfunction getSymbolIterator() {\n    if (!_symbolIterator) {\n        var Symbol_1 = _global['Symbol'];\n        if (Symbol_1 && Symbol_1.iterator) {\n            _symbolIterator = Symbol_1.iterator;\n        }\n        else {\n            // es6-shim specific logic\n            var keys = Object.getOwnPropertyNames(Map.prototype);\n            for (var i = 0; i < keys.length; ++i) {\n                var key = keys[i];\n                if (key !== 'entries' && key !== 'size' &&\n                    Map.prototype[key] === Map.prototype['entries']) {\n                    _symbolIterator = key;\n                }\n            }\n        }\n    }\n    return _symbolIterator;\n}\nfunction scheduleMicroTask(fn) {\n    if (typeof Zone === 'undefined') {\n        // use promise to schedule microTask instead of use Zone\n        promise.then(function () { fn && fn.apply(null, null); });\n    }\n    else {\n        Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n    }\n}\n// JS has NaN !== NaN\nfunction looseIdentical(a, b) {\n    return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);\n}\nfunction stringify(token) {\n    if (typeof token === 'string') {\n        return token;\n    }\n    if (token instanceof Array) {\n        return '[' + token.map(stringify).join(', ') + ']';\n    }\n    if (token == null) {\n        return '' + token;\n    }\n    if (token.overriddenName) {\n        return \"\" + token.overriddenName;\n    }\n    if (token.name) {\n        return \"\" + token.name;\n    }\n    var res = token.toString();\n    if (res == null) {\n        return '' + res;\n    }\n    var newLineIndex = res.indexOf('\\n');\n    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\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 * Attention: These regex has to hold even if the code is minified!\n */\nvar DELEGATE_CTOR = /^function\\s+\\S+\\(\\)\\s*{[\\s\\S]+\\.apply\\(this,\\s*arguments\\)/;\nvar INHERITED_CLASS = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[A-Za-z\\d$_]+\\s*{/;\nvar INHERITED_CLASS_WITH_CTOR = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[A-Za-z\\d$_]+\\s*{[\\s\\S]*constructor\\s*\\(/;\nvar ReflectionCapabilities = /** @class */ (function () {\n    function ReflectionCapabilities(reflect) {\n        this._reflect = reflect || _global['Reflect'];\n    }\n    ReflectionCapabilities.prototype.isReflectionEnabled = function () { return true; };\n    ReflectionCapabilities.prototype.factory = function (t) { return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new (t.bind.apply(t, __spread([void 0], args)))();\n    }; };\n    /** @internal */\n    /** @internal */\n    ReflectionCapabilities.prototype._zipTypesAndAnnotations = /** @internal */\n    function (paramTypes, paramAnnotations) {\n        var result;\n        if (typeof paramTypes === 'undefined') {\n            result = new Array(paramAnnotations.length);\n        }\n        else {\n            result = new Array(paramTypes.length);\n        }\n        for (var 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            }\n            else if (paramTypes[i] != Object) {\n                result[i] = [paramTypes[i]];\n            }\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    ReflectionCapabilities.prototype._ownParameters = function (type, parentCtor) {\n        var typeStr = type.toString();\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(typeStr) ||\n            (INHERITED_CLASS.exec(typeStr) && !INHERITED_CLASS_WITH_CTOR.exec(typeStr))) {\n            return null;\n        }\n        // Prefer the direct API.\n        if (type.parameters && type.parameters !== parentCtor.parameters) {\n            return type.parameters;\n        }\n        // API of tsickle for lowering decorators to properties on the class.\n        var tsickleCtorParams = 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            var ctorParameters = typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;\n            var paramTypes_1 = ctorParameters.map(function (ctorParam) { return ctorParam && ctorParam.type; });\n            var paramAnnotations_1 = ctorParameters.map(function (ctorParam) {\n                return ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators);\n            });\n            return this._zipTypesAndAnnotations(paramTypes_1, paramAnnotations_1);\n        }\n        // API for metadata created by invoking the decorators.\n        var paramAnnotations = type.hasOwnProperty(PARAMETERS) && type[PARAMETERS];\n        var paramTypes = this._reflect && this._reflect.getOwnMetadata &&\n            this._reflect.getOwnMetadata('design:paramtypes', type);\n        if (paramTypes || paramAnnotations) {\n            return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\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.length).fill(undefined);\n    };\n    ReflectionCapabilities.prototype.parameters = function (type) {\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        var parentCtor = getParentCtor(type);\n        var parameters = this._ownParameters(type, parentCtor);\n        if (!parameters && parentCtor !== Object) {\n            parameters = this.parameters(parentCtor);\n        }\n        return parameters || [];\n    };\n    ReflectionCapabilities.prototype._ownAnnotations = function (typeOrFunc, parentCtor) {\n        // Prefer the direct API.\n        if (typeOrFunc.annotations && typeOrFunc.annotations !== parentCtor.annotations) {\n            var annotations = typeOrFunc.annotations;\n            if (typeof annotations === 'function' && annotations.annotations) {\n                annotations = annotations.annotations;\n            }\n            return annotations;\n        }\n        // API of tsickle for lowering decorators to properties on the class.\n        if (typeOrFunc.decorators && typeOrFunc.decorators !== parentCtor.decorators) {\n            return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);\n        }\n        // API for metadata created by invoking the decorators.\n        if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {\n            return typeOrFunc[ANNOTATIONS];\n        }\n        return null;\n    };\n    ReflectionCapabilities.prototype.annotations = function (typeOrFunc) {\n        if (!isType(typeOrFunc)) {\n            return [];\n        }\n        var parentCtor = getParentCtor(typeOrFunc);\n        var ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];\n        var parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];\n        return parentAnnotations.concat(ownAnnotations);\n    };\n    ReflectionCapabilities.prototype._ownPropMetadata = function (typeOrFunc, parentCtor) {\n        // Prefer the direct API.\n        if (typeOrFunc.propMetadata &&\n            typeOrFunc.propMetadata !== parentCtor.propMetadata) {\n            var propMetadata = typeOrFunc.propMetadata;\n            if (typeof propMetadata === 'function' && propMetadata.propMetadata) {\n                propMetadata = propMetadata.propMetadata;\n            }\n            return propMetadata;\n        }\n        // API of tsickle for lowering decorators to properties on the class.\n        if (typeOrFunc.propDecorators &&\n            typeOrFunc.propDecorators !== parentCtor.propDecorators) {\n            var propDecorators_1 = typeOrFunc.propDecorators;\n            var propMetadata_1 = {};\n            Object.keys(propDecorators_1).forEach(function (prop) {\n                propMetadata_1[prop] = convertTsickleDecoratorIntoMetadata(propDecorators_1[prop]);\n            });\n            return propMetadata_1;\n        }\n        // API for metadata created by invoking the decorators.\n        if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {\n            return typeOrFunc[PROP_METADATA];\n        }\n        return null;\n    };\n    ReflectionCapabilities.prototype.propMetadata = function (typeOrFunc) {\n        if (!isType(typeOrFunc)) {\n            return {};\n        }\n        var parentCtor = getParentCtor(typeOrFunc);\n        var propMetadata = {};\n        if (parentCtor !== Object) {\n            var parentPropMetadata_1 = this.propMetadata(parentCtor);\n            Object.keys(parentPropMetadata_1).forEach(function (propName) {\n                propMetadata[propName] = parentPropMetadata_1[propName];\n            });\n        }\n        var ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);\n        if (ownPropMetadata) {\n            Object.keys(ownPropMetadata).forEach(function (propName) {\n                var decorators = [];\n                if (propMetadata.hasOwnProperty(propName)) {\n                    decorators.push.apply(decorators, __spread(propMetadata[propName]));\n                }\n                decorators.push.apply(decorators, __spread(ownPropMetadata[propName]));\n                propMetadata[propName] = decorators;\n            });\n        }\n        return propMetadata;\n    };\n    ReflectionCapabilities.prototype.hasLifecycleHook = function (type, lcProperty) {\n        return type instanceof Type && lcProperty in type.prototype;\n    };\n    ReflectionCapabilities.prototype.guards = function (type) { return {}; };\n    ReflectionCapabilities.prototype.getter = function (name) { return new Function('o', 'return o.' + name + ';'); };\n    ReflectionCapabilities.prototype.setter = function (name) {\n        return new Function('o', 'v', 'return o.' + name + ' = v;');\n    };\n    ReflectionCapabilities.prototype.method = function (name) {\n        var functionBody = \"if (!o.\" + name + \") throw new Error('\\\"\" + name + \"\\\" is undefined');\\n        return o.\" + name + \".apply(o, args);\";\n        return new Function('o', 'args', functionBody);\n    };\n    // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n    // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n    ReflectionCapabilities.prototype.importUri = \n    // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n    function (type) {\n        // StaticSymbol\n        if (typeof type === 'object' && type['filePath']) {\n            return type['filePath'];\n        }\n        // Runtime type\n        return \"./\" + stringify(type);\n    };\n    ReflectionCapabilities.prototype.resourceUri = function (type) { return \"./\" + stringify(type); };\n    ReflectionCapabilities.prototype.resolveIdentifier = function (name, moduleUrl, members, runtime) {\n        return runtime;\n    };\n    ReflectionCapabilities.prototype.resolveEnum = function (enumIdentifier, name) { return enumIdentifier[name]; };\n    return ReflectionCapabilities;\n}());\nfunction convertTsickleDecoratorIntoMetadata(decoratorInvocations) {\n    if (!decoratorInvocations) {\n        return [];\n    }\n    return decoratorInvocations.map(function (decoratorInvocation) {\n        var decoratorType = decoratorInvocation.type;\n        var annotationCls = decoratorType.annotationCls;\n        var annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];\n        return new (annotationCls.bind.apply(annotationCls, __spread([void 0], annotationArgs)))();\n    });\n}\nfunction getParentCtor(ctor) {\n    var parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;\n    var 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/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction getClosureSafeProperty(objWithPropertyToExtract, target) {\n    for (var key in objWithPropertyToExtract) {\n        if (objWithPropertyToExtract[key] === target) {\n            return key;\n        }\n    }\n    throw Error('Could not find renamed property on target object.');\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 * Allows to refer to references which are not yet defined.\n *\n * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of\n * DI is declared,\n * but not yet defined. It is also used when the `token` which we use when creating a query is not\n * yet defined.\n *\n * ### Example\n * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}\n * @experimental\n */\nfunction forwardRef(forwardRefFn) {\n    forwardRefFn.__forward_ref__ = forwardRef;\n    forwardRefFn.toString = function () { return stringify(this()); };\n    return forwardRefFn;\n}\n/**\n * Lazily retrieves the reference value from a forwardRef.\n *\n * Acts as the identity function when given a non-forward-ref value.\n *\n * ### Example ([live demo](http://plnkr.co/edit/GU72mJrk1fiodChcmiDR?p=preview))\n *\n * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}\n *\n * See: {@link forwardRef}\n * @experimental\n */\nfunction resolveForwardRef(type) {\n    if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__') &&\n        type.__forward_ref__ === forwardRef) {\n        return type();\n    }\n    else {\n        return type;\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 * Inject decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Inject = makeParamDecorator('Inject', function (token) { return ({ token: token }); });\n/**\n * Optional decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Optional = makeParamDecorator('Optional');\n/**\n * Self decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Self = makeParamDecorator('Self');\n/**\n * SkipSelf decorator and metadata.\n *\n *\n * @Annotation\n */\nvar SkipSelf = makeParamDecorator('SkipSelf');\n/**\n * Host decorator and metadata.\n *\n *\n * @Annotation\n */\nvar Host = makeParamDecorator('Host');\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar SOURCE = '__source';\nvar _THROW_IF_NOT_FOUND = new Object();\nvar THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n/**\n * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.\n *\n * Requesting this token instead of `Injector` allows `StaticInjector` to be tree-shaken from a\n * project.\n *\n * @experimental\n */\nvar INJECTOR = new InjectionToken('INJECTOR');\nvar NullInjector = /** @class */ (function () {\n    function NullInjector() {\n    }\n    NullInjector.prototype.get = function (token, notFoundValue) {\n        if (notFoundValue === void 0) { notFoundValue = _THROW_IF_NOT_FOUND; }\n        if (notFoundValue === _THROW_IF_NOT_FOUND) {\n            throw new Error(\"NullInjectorError: No provider for \" + stringify(token) + \"!\");\n        }\n        return notFoundValue;\n    };\n    return NullInjector;\n}());\n/**\n * @usageNotes\n * ```\n * const injector: Injector = ...;\n * injector.get(...);\n * ```\n *\n * @description\n *\n * Concrete injectors implement this interface.\n *\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 *\n */\nvar Injector = /** @class */ (function () {\n    function Injector() {\n    }\n    /**\n     * Create a new Injector which is configure using `StaticProvider`s.\n     *\n     * ### Example\n     *\n     * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n     */\n    /**\n       * Create a new Injector which is configure using `StaticProvider`s.\n       *\n       * ### Example\n       *\n       * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n       */\n    Injector.create = /**\n       * Create a new Injector which is configure using `StaticProvider`s.\n       *\n       * ### Example\n       *\n       * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n       */\n    function (options, parent) {\n        if (Array.isArray(options)) {\n            return new StaticInjector(options, parent);\n        }\n        else {\n            return new StaticInjector(options.providers, options.parent, options.name || null);\n        }\n    };\n    Injector.THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n    Injector.NULL = new NullInjector();\n    Injector.ngInjectableDef = defineInjectable({\n        providedIn: 'any',\n        factory: function () { return inject(INJECTOR); },\n    });\n    return Injector;\n}());\nvar IDENT = function (value) {\n    return value;\n};\nvar EMPTY = [];\nvar CIRCULAR = IDENT;\nvar MULTI_PROVIDER_FN = function () {\n    return Array.prototype.slice.call(arguments);\n};\nvar GET_PROPERTY_NAME$1 = {};\nvar USE_VALUE$1 = getClosureSafeProperty$1({ provide: String, useValue: GET_PROPERTY_NAME$1 });\nvar NG_TOKEN_PATH = 'ngTokenPath';\nvar NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\nvar NULL_INJECTOR = Injector.NULL;\nvar NEW_LINE = /\\n/gm;\nvar NO_NEW_LINE = 'ɵ';\nvar StaticInjector = /** @class */ (function () {\n    function StaticInjector(providers, parent, source) {\n        if (parent === void 0) { parent = NULL_INJECTOR; }\n        if (source === void 0) { source = null; }\n        this.parent = parent;\n        this.source = source;\n        var records = this._records = new Map();\n        records.set(Injector, { token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false });\n        records.set(INJECTOR, { token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false });\n        recursivelyProcessProviders(records, providers);\n    }\n    StaticInjector.prototype.get = function (token, notFoundValue, flags) {\n        if (flags === void 0) { flags = 0 /* Default */; }\n        var record = this._records.get(token);\n        try {\n            return tryResolveToken(token, record, this._records, this.parent, notFoundValue, flags);\n        }\n        catch (e) {\n            var tokenPath = e[NG_TEMP_TOKEN_PATH];\n            if (token[SOURCE]) {\n                tokenPath.unshift(token[SOURCE]);\n            }\n            e.message = formatError('\\n' + e.message, tokenPath, this.source);\n            e[NG_TOKEN_PATH] = tokenPath;\n            e[NG_TEMP_TOKEN_PATH] = null;\n            throw e;\n        }\n    };\n    StaticInjector.prototype.toString = function () {\n        var tokens = [], records = this._records;\n        records.forEach(function (v, token) { return tokens.push(stringify(token)); });\n        return \"StaticInjector[\" + tokens.join(', ') + \"]\";\n    };\n    return StaticInjector;\n}());\nfunction resolveProvider(provider) {\n    var deps = computeDeps(provider);\n    var fn = IDENT;\n    var value = EMPTY;\n    var useNew = false;\n    var provide = resolveForwardRef(provider.provide);\n    if (USE_VALUE$1 in provider) {\n        // We need to use USE_VALUE in provider since provider.useValue could be defined as undefined.\n        value = provider.useValue;\n    }\n    else if (provider.useFactory) {\n        fn = provider.useFactory;\n    }\n    else if (provider.useExisting) {\n        // Just use IDENT\n    }\n    else if (provider.useClass) {\n        useNew = true;\n        fn = resolveForwardRef(provider.useClass);\n    }\n    else if (typeof provide == 'function') {\n        useNew = true;\n        fn = provide;\n    }\n    else {\n        throw staticError('StaticProvider does not have [useValue|useFactory|useExisting|useClass] or [provide] is not newable', provider);\n    }\n    return { deps: deps, fn: fn, useNew: useNew, value: value };\n}\nfunction multiProviderMixError(token) {\n    return staticError('Cannot mix multi providers and regular providers', token);\n}\nfunction recursivelyProcessProviders(records, provider) {\n    if (provider) {\n        provider = resolveForwardRef(provider);\n        if (provider instanceof Array) {\n            // if we have an array recurse into the array\n            for (var i = 0; i < provider.length; i++) {\n                recursivelyProcessProviders(records, provider[i]);\n            }\n        }\n        else if (typeof provider === 'function') {\n            // Functions were supported in ReflectiveInjector, but are not here. For safety give useful\n            // error messages\n            throw staticError('Function/Class not supported', provider);\n        }\n        else if (provider && typeof provider === 'object' && provider.provide) {\n            // At this point we have what looks like a provider: {provide: ?, ....}\n            var token = resolveForwardRef(provider.provide);\n            var resolvedProvider = resolveProvider(provider);\n            if (provider.multi === true) {\n                // This is a multi provider.\n                var multiProvider = records.get(token);\n                if (multiProvider) {\n                    if (multiProvider.fn !== MULTI_PROVIDER_FN) {\n                        throw multiProviderMixError(token);\n                    }\n                }\n                else {\n                    // Create a placeholder factory which will look up the constituents of the multi provider.\n                    records.set(token, multiProvider = {\n                        token: provider.provide,\n                        deps: [],\n                        useNew: false,\n                        fn: MULTI_PROVIDER_FN,\n                        value: EMPTY\n                    });\n                }\n                // Treat the provider as the token.\n                token = provider;\n                multiProvider.deps.push({ token: token, options: 6 /* Default */ });\n            }\n            var record = records.get(token);\n            if (record && record.fn == MULTI_PROVIDER_FN) {\n                throw multiProviderMixError(token);\n            }\n            records.set(token, resolvedProvider);\n        }\n        else {\n            throw staticError('Unexpected provider', provider);\n        }\n    }\n}\nfunction tryResolveToken(token, record, records, parent, notFoundValue, flags) {\n    try {\n        return resolveToken(token, record, records, parent, notFoundValue, flags);\n    }\n    catch (e) {\n        // ensure that 'e' is of type Error.\n        if (!(e instanceof Error)) {\n            e = new Error(e);\n        }\n        var path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];\n        path.unshift(token);\n        if (record && record.value == CIRCULAR) {\n            // Reset the Circular flag.\n            record.value = EMPTY;\n        }\n        throw e;\n    }\n}\nfunction resolveToken(token, record, records, parent, notFoundValue, flags) {\n    var value;\n    if (record && !(flags & 4 /* SkipSelf */)) {\n        // If we don't have a record, this implies that we don't own the provider hence don't know how\n        // to resolve it.\n        value = record.value;\n        if (value == CIRCULAR) {\n            throw Error(NO_NEW_LINE + 'Circular dependency');\n        }\n        else if (value === EMPTY) {\n            record.value = CIRCULAR;\n            var obj = undefined;\n            var useNew = record.useNew;\n            var fn = record.fn;\n            var depRecords = record.deps;\n            var deps = EMPTY;\n            if (depRecords.length) {\n                deps = [];\n                for (var i = 0; i < depRecords.length; i++) {\n                    var depRecord = depRecords[i];\n                    var options = depRecord.options;\n                    var childRecord = options & 2 /* CheckSelf */ ? records.get(depRecord.token) : undefined;\n                    deps.push(tryResolveToken(\n                    // Current Token to resolve\n                    depRecord.token, childRecord, records, \n                    // If we don't know how to resolve dependency and we should not check parent for it,\n                    // than pass in Null injector.\n                    !childRecord && !(options & 4 /* CheckParent */) ? NULL_INJECTOR : parent, options & 1 /* Optional */ ? null : Injector.THROW_IF_NOT_FOUND, 0 /* Default */));\n                }\n            }\n            record.value = value = useNew ? new ((_a = fn).bind.apply(_a, __spread([void 0], deps)))() : fn.apply(obj, deps);\n        }\n    }\n    else if (!(flags & 2 /* Self */)) {\n        value = parent.get(token, notFoundValue, 0 /* Default */);\n    }\n    return value;\n    var _a;\n}\nfunction computeDeps(provider) {\n    var deps = EMPTY;\n    var providerDeps = provider.deps;\n    if (providerDeps && providerDeps.length) {\n        deps = [];\n        for (var i = 0; i < providerDeps.length; i++) {\n            var options = 6;\n            var token = resolveForwardRef(providerDeps[i]);\n            if (token instanceof Array) {\n                for (var j = 0, annotations = token; j < annotations.length; j++) {\n                    var annotation = annotations[j];\n                    if (annotation instanceof Optional || annotation == Optional) {\n                        options = options | 1 /* Optional */;\n                    }\n                    else if (annotation instanceof SkipSelf || annotation == SkipSelf) {\n                        options = options & ~2 /* CheckSelf */;\n                    }\n                    else if (annotation instanceof Self || annotation == Self) {\n                        options = options & ~4 /* CheckParent */;\n                    }\n                    else if (annotation instanceof Inject) {\n                        token = annotation.token;\n                    }\n                    else {\n                        token = resolveForwardRef(annotation);\n                    }\n                }\n            }\n            deps.push({ token: token, options: options });\n        }\n    }\n    else if (provider.useExisting) {\n        var token = resolveForwardRef(provider.useExisting);\n        deps = [{ token: token, options: 6 /* Default */ }];\n    }\n    else if (!providerDeps && !(USE_VALUE$1 in provider)) {\n        // useValue & useExisting are the only ones which are exempt from deps all others need it.\n        throw staticError('\\'deps\\' required', provider);\n    }\n    return deps;\n}\nfunction formatError(text, obj, source) {\n    if (source === void 0) { source = null; }\n    text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;\n    var context = stringify(obj);\n    if (obj instanceof Array) {\n        context = obj.map(stringify).join(' -> ');\n    }\n    else if (typeof obj === 'object') {\n        var parts = [];\n        for (var key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                var value = obj[key];\n                parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n            }\n        }\n        context = \"{\" + parts.join(', ') + \"}\";\n    }\n    return \"StaticInjectorError\" + (source ? '(' + source + ')' : '') + \"[\" + context + \"]: \" + text.replace(NEW_LINE, '\\n  ');\n}\nfunction staticError(text, obj) {\n    return new Error(formatError(text, obj));\n}\nfunction getClosureSafeProperty$1(objWithPropertyToExtract) {\n    for (var key in objWithPropertyToExtract) {\n        if (objWithPropertyToExtract[key] === GET_PROPERTY_NAME$1) {\n            return key;\n        }\n    }\n    throw Error('!prop');\n}\n/**\n * Current injector value used by `inject`.\n * - `undefined`: it is an error to call `inject`\n * - `null`: `inject` can be called but there is no injector (limp-mode).\n * - Injector instance: Use the injector for resolution.\n */\nvar _currentInjector = undefined;\nfunction setCurrentInjector(injector) {\n    var former = _currentInjector;\n    _currentInjector = injector;\n    return former;\n}\nfunction inject(token, flags) {\n    if (flags === void 0) { flags = 0 /* Default */; }\n    if (_currentInjector === undefined) {\n        throw new Error(\"inject() must be called from an injection context\");\n    }\n    else if (_currentInjector === null) {\n        var injectableDef = token.ngInjectableDef;\n        if (injectableDef && injectableDef.providedIn == 'root') {\n            return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :\n                injectableDef.value;\n        }\n        throw new Error(\"Injector: NOT_FOUND [\" + stringify(token) + \"]\");\n    }\n    else {\n        return _currentInjector.get(token, flags & 8 /* Optional */ ? null : undefined, flags);\n    }\n}\nfunction injectArgs(types) {\n    var args = [];\n    for (var i = 0; i < types.length; i++) {\n        var arg = types[i];\n        if (Array.isArray(arg)) {\n            if (arg.length === 0) {\n                throw new Error('Arguments array must have arguments.');\n            }\n            var type = undefined;\n            var flags = 0;\n            for (var j = 0; j < arg.length; j++) {\n                var meta = arg[j];\n                if (meta instanceof Optional || meta.__proto__.ngMetadataName === 'Optional') {\n                    flags |= 8 /* Optional */;\n                }\n                else if (meta instanceof SkipSelf || meta.__proto__.ngMetadataName === 'SkipSelf') {\n                    flags |= 4 /* SkipSelf */;\n                }\n                else if (meta instanceof Self || meta.__proto__.ngMetadataName === 'Self') {\n                    flags |= 2 /* Self */;\n                }\n                else if (meta instanceof Inject) {\n                    type = meta.token;\n                }\n                else {\n                    type = meta;\n                }\n            }\n            args.push(inject((type), flags));\n        }\n        else {\n            args.push(inject(arg));\n        }\n    }\n    return args;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar GET_PROPERTY_NAME = {};\nvar ɵ0 = GET_PROPERTY_NAME;\nvar USE_VALUE = getClosureSafeProperty({ provide: String, useValue: ɵ0 }, GET_PROPERTY_NAME);\nvar EMPTY_ARRAY = [];\nfunction convertInjectableProviderToFactory(type, provider) {\n    if (!provider) {\n        var reflectionCapabilities = new ReflectionCapabilities();\n        var deps_1 = reflectionCapabilities.parameters(type);\n        // TODO - convert to flags.\n        return function () { return new (type.bind.apply(type, __spread([void 0], injectArgs(deps_1))))(); };\n    }\n    if (USE_VALUE in provider) {\n        var valueProvider_1 = provider;\n        return function () { return valueProvider_1.useValue; };\n    }\n    else if (provider.useExisting) {\n        var existingProvider_1 = provider;\n        return function () { return inject(existingProvider_1.useExisting); };\n    }\n    else if (provider.useFactory) {\n        var factoryProvider_1 = provider;\n        return function () { return factoryProvider_1.useFactory.apply(factoryProvider_1, __spread(injectArgs(factoryProvider_1.deps || EMPTY_ARRAY))); };\n    }\n    else if (provider.useClass) {\n        var classProvider_1 = provider;\n        var deps_2 = provider.deps;\n        if (!deps_2) {\n            var reflectionCapabilities = new ReflectionCapabilities();\n            deps_2 = reflectionCapabilities.parameters(type);\n        }\n        return function () {\n            return new ((_a = classProvider_1.useClass).bind.apply(_a, __spread([void 0], injectArgs(deps_2))))();\n            var _a;\n        };\n    }\n    else {\n        var deps_3 = provider.deps;\n        if (!deps_3) {\n            var reflectionCapabilities = new ReflectionCapabilities();\n            deps_3 = reflectionCapabilities.parameters(type);\n        }\n        return function () { return new (type.bind.apply(type, __spread([void 0], injectArgs((deps_3)))))(); };\n    }\n}\n/**\n* Injectable decorator and metadata.\n*\n*\n* @Annotation\n*/\nvar Injectable = makeDecorator('Injectable', undefined, undefined, undefined, function (injectableType, options) {\n    if (options && options.providedIn !== undefined &&\n        injectableType.ngInjectableDef === undefined) {\n        injectableType.ngInjectableDef = defineInjectable({\n            providedIn: options.providedIn,\n            factory: convertInjectableProviderToFactory(injectableType, options)\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 * Defines a schema that will allow:\n * - any non-Angular elements with a `-` in their name,\n * - any properties on elements with a `-` in their name which is the common rule for custom\n * elements.\n *\n *\n */\nvar CUSTOM_ELEMENTS_SCHEMA = {\n    name: 'custom-elements'\n};\n/**\n * Defines a schema that will allow any property on any element.\n *\n * @experimental\n */\nvar NO_ERRORS_SCHEMA = {\n    name: 'no-errors-schema'\n};\n/**\n * NgModule decorator and metadata.\n *\n *\n * @Annotation\n */\nvar NgModule = makeDecorator('NgModule', function (ngModule) { return ngModule; }, undefined, undefined, function (moduleType, metadata) {\n    var imports = (metadata && metadata.imports) || [];\n    if (metadata && metadata.exports) {\n        imports = __spread(imports, [metadata.exports]);\n    }\n    moduleType.ngInjectorDef = defineInjector({\n        factory: convertInjectableProviderToFactory(moduleType, { useClass: moduleType }),\n        providers: metadata && metadata.providers,\n        imports: imports,\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 * @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 * Defines template and style encapsulation options available for Component's {@link Component}.\n *\n * See {@link Component#encapsulation encapsulation}.\n *\n */\n/**\n * Defines template and style encapsulation options available for Component's {@link Component}.\n *\n * See {@link Component#encapsulation encapsulation}.\n *\n */\n\n/**\n * Defines template and style encapsulation options available for Component's {@link Component}.\n *\n * See {@link Component#encapsulation encapsulation}.\n *\n */\n(function (ViewEncapsulation) {\n    /**\n     * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host\n     * Element and pre-processing the style rules provided via {@link Component#styles styles} or\n     * {@link Component#styleUrls styleUrls}, and adding the new Host Element attribute to all\n     * selectors.\n     *\n     * This is the default option.\n     */\n    ViewEncapsulation[ViewEncapsulation[\"Emulated\"] = 0] = \"Emulated\";\n    /**\n     * Use the native encapsulation mechanism of the renderer.\n     *\n     * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n     * creating a ShadowRoot for Component's Host Element.\n     */\n    ViewEncapsulation[ViewEncapsulation[\"Native\"] = 1] = \"Native\";\n    /**\n     * Don't provide any template or style encapsulation.\n     */\n    ViewEncapsulation[ViewEncapsulation[\"None\"] = 2] = \"None\";\n})(exports.ViewEncapsulation || (exports.ViewEncapsulation = {}));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description Represents the version of Angular\n *\n *\n */\nvar Version = /** @class */ (function () {\n    function Version(full) {\n        this.full = full;\n        this.major = full.split('.')[0];\n        this.minor = full.split('.')[1];\n        this.patch = full.split('.').slice(2).join('.');\n    }\n    return Version;\n}());\nvar VERSION = new Version('6.0.3');\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\nvar ERROR_DEBUG_CONTEXT = 'ngDebugContext';\nvar ERROR_ORIGINAL_ERROR = 'ngOriginalError';\nvar ERROR_LOGGER = 'ngErrorLogger';\n\nfunction getDebugContext(error) {\n    return error[ERROR_DEBUG_CONTEXT];\n}\nfunction getOriginalError(error) {\n    return error[ERROR_ORIGINAL_ERROR];\n}\nfunction getErrorLogger(error) {\n    return error[ERROR_LOGGER] || defaultErrorLogger;\n}\nfunction defaultErrorLogger(console) {\n    var values = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        values[_i - 1] = arguments[_i];\n    }\n    console.error.apply(console, __spread(values));\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n *\n * @description\n * Provides a hook for centralized exception handling.\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 *\n */\nvar ErrorHandler = /** @class */ (function () {\n    function ErrorHandler() {\n        /**\n           * @internal\n           */\n        this._console = console;\n    }\n    ErrorHandler.prototype.handleError = function (error) {\n        var originalError = this._findOriginalError(error);\n        var 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        var errorLogger = getErrorLogger(error);\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    /** @internal */\n    /** @internal */\n    ErrorHandler.prototype._findContext = /** @internal */\n    function (error) {\n        if (error) {\n            return getDebugContext(error) ? getDebugContext(error) :\n                this._findContext(getOriginalError(error));\n        }\n        return null;\n    };\n    /** @internal */\n    /** @internal */\n    ErrorHandler.prototype._findOriginalError = /** @internal */\n    function (error) {\n        var e = getOriginalError(error);\n        while (e && getOriginalError(e)) {\n            e = getOriginalError(e);\n        }\n        return e;\n    };\n    return ErrorHandler;\n}());\nfunction wrappedError(message, originalError) {\n    var msg = message + \" caused by: \" + (originalError instanceof Error ? originalError.message : originalError);\n    var error = Error(msg);\n    error[ERROR_ORIGINAL_ERROR] = originalError;\n    return error;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction findFirstClosedCycle(keys) {\n    var res = [];\n    for (var 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}\nfunction constructResolvingPath(keys) {\n    if (keys.length > 1) {\n        var reversed = findFirstClosedCycle(keys.slice().reverse());\n        var tokenStrs = reversed.map(function (k) { return stringify(k.token); });\n        return ' (' + tokenStrs.join(' -> ') + ')';\n    }\n    return '';\n}\nfunction injectionError(injector, key, constructResolvingMessage, originalError) {\n    var keys = [key];\n    var errMsg = constructResolvingMessage(keys);\n    var error = (originalError ? wrappedError(errMsg, originalError) : Error(errMsg));\n    error.addKey = addKey;\n    error.keys = keys;\n    error.injectors = [injector];\n    error.constructResolvingMessage = constructResolvingMessage;\n    error[ERROR_ORIGINAL_ERROR] = originalError;\n    return error;\n}\nfunction addKey(injector, key) {\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 */\nfunction noProviderError(injector, key) {\n    return injectionError(injector, key, function (keys) {\n        var 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 */\nfunction cyclicDependencyError(injector, key) {\n    return injectionError(injector, key, function (keys) {\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\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 */\nfunction instantiationError(injector, originalException, originalStack, key) {\n    return injectionError(injector, key, function (keys) {\n        var 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 */\nfunction invalidProviderError(provider) {\n    return Error(\"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 *\n */\nfunction noAnnotationError(typeOrFunc, params) {\n    var signature = [];\n    for (var i = 0, ii = params.length; i < ii; i++) {\n        var parameter = params[i];\n        if (!parameter || parameter.length == 0) {\n            signature.push('?');\n        }\n        else {\n            signature.push(parameter.map(stringify).join(' '));\n        }\n    }\n    return Error('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 *\n */\nfunction outOfBoundsError(index) {\n    return Error(\"Index \" + index + \" is out-of-bounds.\");\n}\n// TODO: add a working example after alpha38 is released\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 */\nfunction mixingMultiProvidersWithRegularProvidersError(provider1, provider2) {\n    return Error(\"Cannot mix multi providers and regular providers, got: \" + provider1 + \" \" + provider2);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A 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 * @deprecated No replacement\n */\nvar ReflectiveKey = /** @class */ (function () {\n    /**\n     * Private\n     */\n    function ReflectiveKey(token, id) {\n        this.token = token;\n        this.id = id;\n        if (!token) {\n            throw new Error('Token must be defined!');\n        }\n        this.displayName = stringify(this.token);\n    }\n    /**\n     * Retrieves a `Key` for a token.\n     */\n    /**\n       * Retrieves a `Key` for a token.\n       */\n    ReflectiveKey.get = /**\n       * Retrieves a `Key` for a token.\n       */\n    function (token) {\n        return _globalKeyRegistry.get(resolveForwardRef(token));\n    };\n    Object.defineProperty(ReflectiveKey, \"numberOfKeys\", {\n        /**\n         * @returns the number of keys registered in the system.\n         */\n        get: /**\n           * @returns the number of keys registered in the system.\n           */\n        function () { return _globalKeyRegistry.numberOfKeys; },\n        enumerable: true,\n        configurable: true\n    });\n    return ReflectiveKey;\n}());\nvar KeyRegistry = /** @class */ (function () {\n    function KeyRegistry() {\n        this._allKeys = new Map();\n    }\n    KeyRegistry.prototype.get = function (token) {\n        if (token instanceof ReflectiveKey)\n            return token;\n        if (this._allKeys.has(token)) {\n            return this._allKeys.get(token);\n        }\n        var newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);\n        this._allKeys.set(token, newKey);\n        return newKey;\n    };\n    Object.defineProperty(KeyRegistry.prototype, \"numberOfKeys\", {\n        get: function () { return this._allKeys.size; },\n        enumerable: true,\n        configurable: true\n    });\n    return KeyRegistry;\n}());\nvar _globalKeyRegistry = new KeyRegistry();\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 * Provides access to reflection data about symbols. Used internally by Angular\n * to power dependency injection and compilation.\n */\nvar Reflector = /** @class */ (function () {\n    function Reflector(reflectionCapabilities) {\n        this.reflectionCapabilities = reflectionCapabilities;\n    }\n    Reflector.prototype.updateCapabilities = function (caps) { this.reflectionCapabilities = caps; };\n    Reflector.prototype.factory = function (type) { return this.reflectionCapabilities.factory(type); };\n    Reflector.prototype.parameters = function (typeOrFunc) {\n        return this.reflectionCapabilities.parameters(typeOrFunc);\n    };\n    Reflector.prototype.annotations = function (typeOrFunc) {\n        return this.reflectionCapabilities.annotations(typeOrFunc);\n    };\n    Reflector.prototype.propMetadata = function (typeOrFunc) {\n        return this.reflectionCapabilities.propMetadata(typeOrFunc);\n    };\n    Reflector.prototype.hasLifecycleHook = function (type, lcProperty) {\n        return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);\n    };\n    Reflector.prototype.getter = function (name) { return this.reflectionCapabilities.getter(name); };\n    Reflector.prototype.setter = function (name) { return this.reflectionCapabilities.setter(name); };\n    Reflector.prototype.method = function (name) { return this.reflectionCapabilities.method(name); };\n    Reflector.prototype.importUri = function (type) { return this.reflectionCapabilities.importUri(type); };\n    Reflector.prototype.resourceUri = function (type) { return this.reflectionCapabilities.resourceUri(type); };\n    Reflector.prototype.resolveIdentifier = function (name, moduleUrl, members, runtime) {\n        return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);\n    };\n    Reflector.prototype.resolveEnum = function (identifier, name) {\n        return this.reflectionCapabilities.resolveEnum(identifier, name);\n    };\n    return Reflector;\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 * The {@link Reflector} used internally in Angular to access metadata\n * about symbols.\n */\nvar reflector = new Reflector(new ReflectionCapabilities());\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 * `Dependency` is used by the framework to extend DI.\n * This is internal to Angular and should not be used directly.\n */\nvar ReflectiveDependency = /** @class */ (function () {\n    function ReflectiveDependency(key, optional, visibility) {\n        this.key = key;\n        this.optional = optional;\n        this.visibility = visibility;\n    }\n    ReflectiveDependency.fromKey = function (key) {\n        return new ReflectiveDependency(key, false, null);\n    };\n    return ReflectiveDependency;\n}());\nvar _EMPTY_LIST = [];\nvar ResolvedReflectiveProvider_ = /** @class */ (function () {\n    function ResolvedReflectiveProvider_(key, resolvedFactories, multiProvider) {\n        this.key = key;\n        this.resolvedFactories = resolvedFactories;\n        this.multiProvider = multiProvider;\n        this.resolvedFactory = this.resolvedFactories[0];\n    }\n    return ResolvedReflectiveProvider_;\n}());\n/**\n * An internal resolved representation of a factory function created by resolving {@link\n * Provider}.\n * @experimental\n */\nvar ResolvedReflectiveFactory = /** @class */ (function () {\n    function ResolvedReflectiveFactory(/**\n           * Factory function which can return an instance of an object represented by a key.\n           */\n    factory, /**\n           * Arguments (dependencies) to the `factory` function.\n           */\n    dependencies) {\n        this.factory = factory;\n        this.dependencies = dependencies;\n    }\n    return ResolvedReflectiveFactory;\n}());\n/**\n * Resolve a single provider.\n */\nfunction resolveReflectiveFactory(provider) {\n    var factoryFn;\n    var resolvedDeps;\n    if (provider.useClass) {\n        var useClass = resolveForwardRef(provider.useClass);\n        factoryFn = reflector.factory(useClass);\n        resolvedDeps = _dependenciesFor(useClass);\n    }\n    else if (provider.useExisting) {\n        factoryFn = function (aliasInstance) { return aliasInstance; };\n        resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];\n    }\n    else if (provider.useFactory) {\n        factoryFn = provider.useFactory;\n        resolvedDeps = constructDependencies(provider.useFactory, provider.deps);\n    }\n    else {\n        factoryFn = function () { return 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 */\nfunction resolveReflectiveProvider(provider) {\n    return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);\n}\n/**\n * Resolve a list of Providers.\n */\nfunction resolveReflectiveProviders(providers) {\n    var normalized = _normalizeProviders(providers, []);\n    var resolved = normalized.map(resolveReflectiveProvider);\n    var 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 */\nfunction mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {\n    for (var i = 0; i < providers.length; i++) {\n        var provider = providers[i];\n        var 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 (var j = 0; j < provider.resolvedFactories.length; j++) {\n                    existing.resolvedFactories.push(provider.resolvedFactories[j]);\n                }\n            }\n            else {\n                normalizedProvidersMap.set(provider.key.id, provider);\n            }\n        }\n        else {\n            var resolvedProvider = void 0;\n            if (provider.multiProvider) {\n                resolvedProvider = new ResolvedReflectiveProvider_(provider.key, provider.resolvedFactories.slice(), provider.multiProvider);\n            }\n            else {\n                resolvedProvider = provider;\n            }\n            normalizedProvidersMap.set(provider.key.id, resolvedProvider);\n        }\n    }\n    return normalizedProvidersMap;\n}\nfunction _normalizeProviders(providers, res) {\n    providers.forEach(function (b) {\n        if (b instanceof Type) {\n            res.push({ provide: b, useClass: b });\n        }\n        else if (b && typeof b == 'object' && b.provide !== undefined) {\n            res.push(b);\n        }\n        else if (b instanceof Array) {\n            _normalizeProviders(b, res);\n        }\n        else {\n            throw invalidProviderError(b);\n        }\n    });\n    return res;\n}\nfunction constructDependencies(typeOrFunc, dependencies) {\n    if (!dependencies) {\n        return _dependenciesFor(typeOrFunc);\n    }\n    else {\n        var params_1 = dependencies.map(function (t) { return [t]; });\n        return dependencies.map(function (t) { return _extractToken(typeOrFunc, t, params_1); });\n    }\n}\nfunction _dependenciesFor(typeOrFunc) {\n    var params = reflector.parameters(typeOrFunc);\n    if (!params)\n        return [];\n    if (params.some(function (p) { return p == null; })) {\n        throw noAnnotationError(typeOrFunc, params);\n    }\n    return params.map(function (p) { return _extractToken(typeOrFunc, p, params); });\n}\nfunction _extractToken(typeOrFunc, metadata, params) {\n    var token = null;\n    var optional = false;\n    if (!Array.isArray(metadata)) {\n        if (metadata instanceof Inject) {\n            return _createDependency(metadata.token, optional, null);\n        }\n        else {\n            return _createDependency(metadata, optional, null);\n        }\n    }\n    var visibility = null;\n    for (var i = 0; i < metadata.length; ++i) {\n        var paramMetadata = metadata[i];\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        }\n        else if (paramMetadata instanceof InjectionToken) {\n            token = paramMetadata;\n        }\n    }\n    token = resolveForwardRef(token);\n    if (token != null) {\n        return _createDependency(token, optional, visibility);\n    }\n    else {\n        throw noAnnotationError(typeOrFunc, params);\n    }\n}\nfunction _createDependency(token, optional, visibility) {\n    return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);\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// Threshold for the dynamic version\nvar 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 * @deprecated from v5 - slow and brings in a lot of code, Use `Injector.create` instead.\n */\nvar ReflectiveInjector = /** @class */ (function () {\n    function ReflectiveInjector() {\n    }\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 fromResolvedProviders} for more info.\n     */\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 fromResolvedProviders} for more info.\n       */\n    ReflectiveInjector.resolve = /**\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 fromResolvedProviders} for more info.\n       */\n    function (providers) {\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 resolve} and\n     * {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders}.\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 resolve} and\n       * {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders}.\n       */\n    ReflectiveInjector.resolveAndCreate = /**\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 resolve} and\n       * {@link ReflectiveInjector#fromResolvedProviders fromResolvedProviders}.\n       */\n    function (providers, parent) {\n        var 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     */\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       */\n    ReflectiveInjector.fromResolvedProviders = /**\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       */\n    function (providers, parent) {\n        return new ReflectiveInjector_(providers, parent);\n    };\n    return ReflectiveInjector;\n}());\nvar ReflectiveInjector_ = /** @class */ (function () {\n    /**\n     * Private\n     */\n    function ReflectiveInjector_(_providers, _parent) {\n        /** @internal */\n        this._constructionCounter = 0;\n        this._providers = _providers;\n        this.parent = _parent || null;\n        var len = _providers.length;\n        this.keyIds = new Array(len);\n        this.objs = new Array(len);\n        for (var i = 0; i < len; i++) {\n            this.keyIds[i] = _providers[i].key.id;\n            this.objs[i] = UNDEFINED;\n        }\n    }\n    ReflectiveInjector_.prototype.get = function (token, notFoundValue) {\n        if (notFoundValue === void 0) { notFoundValue = THROW_IF_NOT_FOUND; }\n        return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);\n    };\n    ReflectiveInjector_.prototype.resolveAndCreateChild = function (providers) {\n        var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);\n        return this.createChildFromResolved(ResolvedReflectiveProviders);\n    };\n    ReflectiveInjector_.prototype.createChildFromResolved = function (providers) {\n        var inj = new ReflectiveInjector_(providers);\n        inj.parent = this;\n        return inj;\n    };\n    ReflectiveInjector_.prototype.resolveAndInstantiate = function (provider) {\n        return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);\n    };\n    ReflectiveInjector_.prototype.instantiateResolved = function (provider) {\n        return this._instantiateProvider(provider);\n    };\n    ReflectiveInjector_.prototype.getProviderAtIndex = function (index) {\n        if (index < 0 || index >= this._providers.length) {\n            throw outOfBoundsError(index);\n        }\n        return this._providers[index];\n    };\n    /** @internal */\n    /** @internal */\n    ReflectiveInjector_.prototype._new = /** @internal */\n    function (provider) {\n        if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {\n            throw cyclicDependencyError(this, provider.key);\n        }\n        return this._instantiateProvider(provider);\n    };\n    ReflectiveInjector_.prototype._getMaxNumberOfObjects = function () { return this.objs.length; };\n    ReflectiveInjector_.prototype._instantiateProvider = function (provider) {\n        if (provider.multiProvider) {\n            var res = new Array(provider.resolvedFactories.length);\n            for (var i = 0; i < provider.resolvedFactories.length; ++i) {\n                res[i] = this._instantiate(provider, provider.resolvedFactories[i]);\n            }\n            return res;\n        }\n        else {\n            return this._instantiate(provider, provider.resolvedFactories[0]);\n        }\n    };\n    ReflectiveInjector_.prototype._instantiate = function (provider, ResolvedReflectiveFactory$$1) {\n        var _this = this;\n        var factory = ResolvedReflectiveFactory$$1.factory;\n        var deps;\n        try {\n            deps =\n                ResolvedReflectiveFactory$$1.dependencies.map(function (dep) { return _this._getByReflectiveDependency(dep); });\n        }\n        catch (e) {\n            if (e.addKey) {\n                e.addKey(this, provider.key);\n            }\n            throw e;\n        }\n        var obj;\n        try {\n            obj = factory.apply(void 0, __spread(deps));\n        }\n        catch (e) {\n            throw instantiationError(this, e, e.stack, provider.key);\n        }\n        return obj;\n    };\n    ReflectiveInjector_.prototype._getByReflectiveDependency = function (dep) {\n        return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);\n    };\n    ReflectiveInjector_.prototype._getByKey = function (key, visibility, notFoundValue) {\n        if (key === ReflectiveInjector_.INJECTOR_KEY) {\n            return this;\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    ReflectiveInjector_.prototype._getObjByKeyId = function (keyId) {\n        for (var 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                return this.objs[i];\n            }\n        }\n        return UNDEFINED;\n    };\n    /** @internal */\n    /** @internal */\n    ReflectiveInjector_.prototype._throwOrNull = /** @internal */\n    function (key, notFoundValue) {\n        if (notFoundValue !== THROW_IF_NOT_FOUND) {\n            return notFoundValue;\n        }\n        else {\n            throw noProviderError(this, key);\n        }\n    };\n    /** @internal */\n    /** @internal */\n    ReflectiveInjector_.prototype._getByKeySelf = /** @internal */\n    function (key, notFoundValue) {\n        var obj = this._getObjByKeyId(key.id);\n        return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);\n    };\n    /** @internal */\n    /** @internal */\n    ReflectiveInjector_.prototype._getByKeyDefault = /** @internal */\n    function (key, notFoundValue, visibility) {\n        var inj;\n        if (visibility instanceof SkipSelf) {\n            inj = this.parent;\n        }\n        else {\n            inj = this;\n        }\n        while (inj instanceof ReflectiveInjector_) {\n            var inj_ = inj;\n            var obj = inj_._getObjByKeyId(key.id);\n            if (obj !== UNDEFINED)\n                return obj;\n            inj = inj_.parent;\n        }\n        if (inj !== null) {\n            return inj.get(key.token, notFoundValue);\n        }\n        else {\n            return this._throwOrNull(key, notFoundValue);\n        }\n    };\n    Object.defineProperty(ReflectiveInjector_.prototype, \"displayName\", {\n        get: function () {\n            var providers = _mapProviders(this, function (b) { return ' \"' + b.key.displayName + '\" '; })\n                .join(', ');\n            return \"ReflectiveInjector(providers: [\" + providers + \"])\";\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ReflectiveInjector_.prototype.toString = function () { return this.displayName; };\n    ReflectiveInjector_.INJECTOR_KEY = ReflectiveKey.get(Injector);\n    return ReflectiveInjector_;\n}());\nfunction _mapProviders(injector, fn) {\n    var res = new Array(injector._providers.length);\n    for (var i = 0; i < injector._providers.length; ++i) {\n        res[i] = fn(injector.getProviderAtIndex(i));\n    }\n    return res;\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 * An internal token whose presence in an injector indicates that the injector should treat itself\n * as a root scoped injector when processing requests for unknown tokens which may indicate\n * they are provided in the root scope.\n */\nvar APP_ROOT = new InjectionToken('The presence of this token marks an injector as being the root injector.');\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 * Marker which indicates that a value has not yet been created from the factory function.\n */\nvar NOT_YET = {};\n/**\n * Marker which indicates that the factory function for a token is in the process of being called.\n *\n * If the injector is asked to inject a token with its value set to CIRCULAR, that indicates\n * injection of a dependency has recursively attempted to inject the original token, and there is\n * a circular dependency among the providers.\n */\nvar CIRCULAR$1 = {};\nvar EMPTY_ARRAY$1 = [];\n/**\n * A lazily initialized NullInjector.\n */\nvar NULL_INJECTOR$1 = undefined;\nfunction getNullInjector() {\n    if (NULL_INJECTOR$1 === undefined) {\n        NULL_INJECTOR$1 = new NullInjector();\n    }\n    return NULL_INJECTOR$1;\n}\n/**\n * Create a new `Injector` which is configured using `InjectorType`s.\n *\n * @experimental\n */\nfunction createInjector(defType, parent) {\n    if (parent === void 0) { parent = null; }\n    parent = parent || getNullInjector();\n    return new R3Injector(defType, parent);\n}\nvar R3Injector = /** @class */ (function () {\n    function R3Injector(def, parent) {\n        var _this = this;\n        this.parent = parent;\n        /**\n           * Map of tokens to records which contain the instances of those tokens.\n           */\n        this.records = new Map();\n        /**\n           * The transitive set of `InjectorType`s which define this injector.\n           */\n        this.injectorDefTypes = new Set();\n        /**\n           * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.\n           */\n        this.onDestroy = new Set();\n        /**\n           * Flag indicating that this injector was previously destroyed.\n           */\n        this.destroyed = false;\n        // Start off by creating Records for every provider declared in every InjectorType\n        // included transitively in `def`.\n        deepForEach([def], function (injectorDef) { return _this.processInjectorType(injectorDef, new Set()); });\n        // Make sure the INJECTOR token provides this injector.\n        this.records.set(INJECTOR, makeRecord(undefined, this));\n        // Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide\n        // any injectable scoped to APP_ROOT_SCOPE.\n        this.isRootInjector = this.records.has(APP_ROOT);\n        // Eagerly instantiate the InjectorType classes themselves.\n        this.injectorDefTypes.forEach(function (defType) { return _this.get(defType); });\n    }\n    /**\n     * Destroy the injector and release references to every instance or provider associated with it.\n     *\n     * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a\n     * hook was found.\n     */\n    /**\n       * Destroy the injector and release references to every instance or provider associated with it.\n       *\n       * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a\n       * hook was found.\n       */\n    R3Injector.prototype.destroy = /**\n       * Destroy the injector and release references to every instance or provider associated with it.\n       *\n       * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a\n       * hook was found.\n       */\n    function () {\n        this.assertNotDestroyed();\n        // Set destroyed = true first, in case lifecycle hooks re-enter destroy().\n        this.destroyed = true;\n        try {\n            // Call all the lifecycle hooks.\n            this.onDestroy.forEach(function (service) { return service.ngOnDestroy(); });\n        }\n        finally {\n            // Release all references.\n            this.records.clear();\n            this.onDestroy.clear();\n            this.injectorDefTypes.clear();\n        }\n    };\n    R3Injector.prototype.get = function (token, notFoundValue, flags) {\n        if (notFoundValue === void 0) { notFoundValue = THROW_IF_NOT_FOUND; }\n        if (flags === void 0) { flags = 0 /* Default */; }\n        this.assertNotDestroyed();\n        // Set the injection context.\n        var previousInjector = setCurrentInjector(this);\n        try {\n            // Check for the SkipSelf flag.\n            if (!(flags & 4 /* SkipSelf */)) {\n                // SkipSelf isn't set, check if the record belongs to this injector.\n                var record = this.records.get(token);\n                if (record === undefined) {\n                    // No record, but maybe the token is scoped to this injector. Look for an ngInjectableDef\n                    // with a scope matching this injector.\n                    var def = couldBeInjectableType(token) &&\n                        token.ngInjectableDef ||\n                        undefined;\n                    if (def !== undefined && this.injectableDefInScope(def)) {\n                        // Found an ngInjectableDef and it's scoped to this injector. Pretend as if it was here\n                        // all along.\n                        record = injectableDefRecord(token);\n                        this.records.set(token, record);\n                    }\n                }\n                // If a record was found, get the instance for it and return it.\n                if (record !== undefined) {\n                    return this.hydrate(token, record);\n                }\n            }\n            // Select the next injector based on the Self flag - if self is set, the next injector is\n            // the NullInjector, otherwise it's the parent.\n            var next = !(flags & 2 /* Self */) ? this.parent : getNullInjector();\n            return this.parent.get(token, notFoundValue);\n        }\n        finally {\n            // Lastly, clean up the state by restoring the previous injector.\n            setCurrentInjector(previousInjector);\n        }\n    };\n    R3Injector.prototype.assertNotDestroyed = function () {\n        if (this.destroyed) {\n            throw new Error('Injector has already been destroyed.');\n        }\n    };\n    /**\n     * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers\n     * to this injector.\n     */\n    /**\n       * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers\n       * to this injector.\n       */\n    R3Injector.prototype.processInjectorType = /**\n       * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers\n       * to this injector.\n       */\n    function (defOrWrappedDef, parents) {\n        var _this = this;\n        defOrWrappedDef = resolveForwardRef(defOrWrappedDef);\n        // Either the defOrWrappedDef is an InjectorType (with ngInjectorDef) or an\n        // InjectorDefTypeWithProviders (aka ModuleWithProviders). Detecting either is a megamorphic\n        // read, so care is taken to only do the read once.\n        // First attempt to read the ngInjectorDef.\n        var def = defOrWrappedDef.ngInjectorDef;\n        // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.\n        var ngModule = (def == null) && defOrWrappedDef.ngModule || undefined;\n        // Determine the InjectorType. In the case where `defOrWrappedDef` is an `InjectorType`,\n        // then this is easy. In the case of an InjectorDefTypeWithProviders, then the definition type\n        // is the `ngModule`.\n        var defType = (ngModule === undefined) ? defOrWrappedDef : ngModule;\n        // If defOrWrappedType was an InjectorDefTypeWithProviders, then .providers may hold some\n        // extra providers.\n        var providers = (ngModule !== undefined) && defOrWrappedDef.providers ||\n            EMPTY_ARRAY$1;\n        // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual\n        // `InjectorDef` is on its `ngModule`.\n        if (ngModule !== undefined) {\n            def = ngModule.ngInjectorDef;\n        }\n        // If no definition was found, throw.\n        if (def == null) {\n            throw new Error(\"Type \" + stringify(defType) + \" is missing an ngInjectorDef definition.\");\n        }\n        // Check for circular dependencies.\n        if (parents.has(defType)) {\n            throw new Error(\"Circular dependency: type \" + stringify(defType) + \" ends up importing itself.\");\n        }\n        // Track the InjectorType and add a provider for it.\n        this.injectorDefTypes.add(defType);\n        this.records.set(defType, makeRecord(def.factory));\n        // Add providers in the same way that @NgModule resolution did:\n        // First, include providers from any imports.\n        if (def.imports != null) {\n            // Before processing defType's imports, add it to the set of parents. This way, if it ends\n            // up deeply importing itself, this can be detected.\n            parents.add(defType);\n            try {\n                deepForEach(def.imports, function (imported) { return _this.processInjectorType(imported, parents); });\n            }\n            finally {\n                // Remove it from the parents set when finished.\n                parents.delete(defType);\n            }\n        }\n        // Next, include providers listed on the definition itself.\n        if (def.providers != null) {\n            deepForEach(def.providers, function (provider) { return _this.processProvider(provider); });\n        }\n        // Finally, include providers from an InjectorDefTypeWithProviders if there was one.\n        deepForEach(providers, function (provider) { return _this.processProvider(provider); });\n    };\n    /**\n     * Process a `SingleProvider` and add it.\n     */\n    /**\n       * Process a `SingleProvider` and add it.\n       */\n    R3Injector.prototype.processProvider = /**\n       * Process a `SingleProvider` and add it.\n       */\n    function (provider) {\n        // Determine the token from the provider. Either it's its own token, or has a {provide: ...}\n        // property.\n        provider = resolveForwardRef(provider);\n        var token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);\n        // Construct a `Record` for the provider.\n        var record = providerToRecord(provider);\n        if (!isTypeProvider(provider) && provider.multi === true) {\n            // If the provider indicates that it's a multi-provider, process it specially.\n            // First check whether it's been defined already.\n            var multiRecord_1 = this.records.get(token);\n            if (multiRecord_1) {\n                // It has. Throw a nice error if\n                if (multiRecord_1.multi === undefined) {\n                    throw new Error(\"Mixed multi-provider for \" + token + \".\");\n                }\n            }\n            else {\n                token = provider;\n                multiRecord_1 = makeRecord(undefined, NOT_YET, true);\n                multiRecord_1.factory = function () { return injectArgs((multiRecord_1.multi)); };\n                this.records.set(token, multiRecord_1);\n            }\n            token = provider;\n            multiRecord_1.multi.push(provider);\n        }\n        var existing = this.records.get(token);\n        if (existing && existing.multi !== undefined) {\n            throw new Error(\"Mixed multi-provider for \" + token);\n        }\n        this.records.set(token, record);\n    };\n    R3Injector.prototype.hydrate = function (token, record) {\n        if (record.value === CIRCULAR$1) {\n            throw new Error(\"Circular dep for \" + stringify(token));\n        }\n        else if (record.value === NOT_YET) {\n            record.value = CIRCULAR$1;\n            record.value = record.factory();\n        }\n        if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {\n            this.onDestroy.add(record.value);\n        }\n        return record.value;\n    };\n    R3Injector.prototype.injectableDefInScope = function (def) {\n        if (!def.providedIn) {\n            return false;\n        }\n        else if (typeof def.providedIn === 'string') {\n            return def.providedIn === 'any' || (def.providedIn === 'root' && this.isRootInjector);\n        }\n        else {\n            return this.injectorDefTypes.has(def.providedIn);\n        }\n    };\n    return R3Injector;\n}());\nfunction injectableDefRecord(token) {\n    var def = token.ngInjectableDef;\n    if (def === undefined) {\n        throw new Error(\"Type \" + stringify(token) + \" is missing an ngInjectableDef definition.\");\n    }\n    return makeRecord(def.factory);\n}\nfunction providerToRecord(provider) {\n    var token = resolveForwardRef(provider);\n    var value = NOT_YET;\n    var factory = undefined;\n    if (isTypeProvider(provider)) {\n        return injectableDefRecord(provider);\n    }\n    else {\n        token = resolveForwardRef(provider.provide);\n        if (isValueProvider(provider)) {\n            value = provider.useValue;\n        }\n        else if (isExistingProvider(provider)) {\n            factory = function () { return inject(provider.useExisting); };\n        }\n        else if (isFactoryProvider(provider)) {\n            factory = function () { return provider.useFactory.apply(provider, __spread(injectArgs(provider.deps || []))); };\n        }\n        else {\n            var classRef_1 = provider.useClass || token;\n            if (hasDeps(provider)) {\n                factory = function () { return new ((classRef_1).bind.apply((classRef_1), __spread([void 0], injectArgs(provider.deps))))(); };\n            }\n            else {\n                return injectableDefRecord(classRef_1);\n            }\n        }\n    }\n    return makeRecord(factory, value);\n}\nfunction makeRecord(factory, value, multi) {\n    if (value === void 0) { value = NOT_YET; }\n    if (multi === void 0) { multi = false; }\n    return {\n        factory: factory,\n        value: value,\n        multi: multi ? [] : undefined,\n    };\n}\nfunction deepForEach(input, fn) {\n    input.forEach(function (value) { return Array.isArray(value) ? deepForEach(value, fn) : fn(value); });\n}\nfunction isValueProvider(value) {\n    return USE_VALUE$1 in value;\n}\nfunction isExistingProvider(value) {\n    return !!value.useExisting;\n}\nfunction isFactoryProvider(value) {\n    return !!value.useFactory;\n}\nfunction isTypeProvider(value) {\n    return typeof value === 'function';\n}\nfunction hasDeps(value) {\n    return !!value.deps;\n}\nfunction hasOnDestroy(value) {\n    return typeof value === 'object' && value != null && value.ngOnDestroy &&\n        typeof value.ngOnDestroy === 'function';\n}\nfunction couldBeInjectableType(value) {\n    return (typeof value === 'function') ||\n        (typeof value === 'object' && value instanceof InjectionToken);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Determine if the argument is shaped like a Promise\n */\nfunction isPromise(obj) {\n    // allow any Promise/A+ compliant thenable.\n    // It's up to the caller to ensure that obj.then conforms to the spec\n    return !!obj && typeof obj.then === 'function';\n}\n/**\n * Determine if the argument is an Observable\n */\nfunction isObservable(obj) {\n    // TODO: use Symbol.observable when https://github.com/ReactiveX/rxjs/issues/2415 will be resolved\n    return !!obj && typeof obj.subscribe === 'function';\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A function that will be executed when an application is initialized.\n * @experimental\n */\nvar APP_INITIALIZER = new InjectionToken('Application Initializer');\n/**\n * A class that reflects the state of running {@link APP_INITIALIZER}s.\n *\n * @experimental\n */\nvar ApplicationInitStatus = /** @class */ (function () {\n    function ApplicationInitStatus(appInits) {\n        var _this = this;\n        this.appInits = appInits;\n        this.initialized = false;\n        this.done = false;\n        this.donePromise = new Promise(function (res, rej) {\n            _this.resolve = res;\n            _this.reject = rej;\n        });\n    }\n    /** @internal */\n    /** @internal */\n    ApplicationInitStatus.prototype.runInitializers = /** @internal */\n    function () {\n        var _this = this;\n        if (this.initialized) {\n            return;\n        }\n        var asyncInitPromises = [];\n        var complete = function () {\n            _this.done = true;\n            _this.resolve();\n        };\n        if (this.appInits) {\n            for (var i = 0; i < this.appInits.length; i++) {\n                var initResult = this.appInits[i]();\n                if (isPromise(initResult)) {\n                    asyncInitPromises.push(initResult);\n                }\n            }\n        }\n        Promise.all(asyncInitPromises).then(function () { complete(); }).catch(function (e) { _this.reject(e); });\n        if (asyncInitPromises.length === 0) {\n            complete();\n        }\n        this.initialized = true;\n    };\n    ApplicationInitStatus.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    ApplicationInitStatus.ctorParameters = function () { return [\n        { type: Array, decorators: [{ type: Inject, args: [APP_INITIALIZER,] }, { type: Optional },] },\n    ]; };\n    return ApplicationInitStatus;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A DI Token representing a unique string id assigned to the application by Angular and used\n * primarily for prefixing application attributes and CSS styles when\n * {@link ViewEncapsulation#Emulated ViewEncapsulation.Emulated} is being used.\n *\n * If you need to avoid randomly generated value to be used as an application id, you can provide\n * a custom value via a DI provider <!-- TODO: provider --> configuring the root {@link Injector}\n * using this token.\n * @experimental\n */\nvar APP_ID = new InjectionToken('AppId');\nfunction _appIdRandomProviderFactory() {\n    return \"\" + _randomChar() + _randomChar() + _randomChar();\n}\n/**\n * Providers that will generate a random APP_ID_TOKEN.\n * @experimental\n */\nvar APP_ID_RANDOM_PROVIDER = {\n    provide: APP_ID,\n    useFactory: _appIdRandomProviderFactory,\n    deps: [],\n};\nfunction _randomChar() {\n    return String.fromCharCode(97 + Math.floor(Math.random() * 25));\n}\n/**\n * A function that will be executed when a platform is initialized.\n * @experimental\n */\nvar PLATFORM_INITIALIZER = new InjectionToken('Platform Initializer');\n/**\n * A token that indicates an opaque platform id.\n * @experimental\n */\nvar PLATFORM_ID = new InjectionToken('Platform ID');\n/**\n * All callbacks provided via this token will be called for every component that is bootstrapped.\n * Signature of the callback:\n *\n * `(componentRef: ComponentRef) => void`.\n *\n * @experimental\n */\nvar APP_BOOTSTRAP_LISTENER = new InjectionToken('appBootstrapListener');\n/**\n * A token which indicates the root directory of the application\n * @experimental\n */\nvar PACKAGE_ROOT_URL = new InjectionToken('Application Packages Root URL');\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar Console = /** @class */ (function () {\n    function Console() {\n    }\n    Console.prototype.log = function (message) {\n        // tslint:disable-next-line:no-console\n        console.log(message);\n    };\n    // Note: for reporting errors use `DOM.logError()` as it is platform specific\n    // Note: for reporting errors use `DOM.logError()` as it is platform specific\n    Console.prototype.warn = \n    // Note: for reporting errors use `DOM.logError()` as it is platform specific\n    function (message) {\n        // tslint:disable-next-line:no-console\n        console.warn(message);\n    };\n    Console.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    Console.ctorParameters = function () { return []; };\n    return Console;\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 * Combination of NgModuleFactory and ComponentFactorys.\n *\n * @experimental\n */\nvar ModuleWithComponentFactories = /** @class */ (function () {\n    function ModuleWithComponentFactories(ngModuleFactory, componentFactories) {\n        this.ngModuleFactory = ngModuleFactory;\n        this.componentFactories = componentFactories;\n    }\n    return ModuleWithComponentFactories;\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 *\n */\nvar Compiler = /** @class */ (function () {\n    function Compiler() {\n    }\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     */\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       */\n    Compiler.prototype.compileModuleSync = /**\n       * Compiles the given NgModule and all of its components. All templates of the components listed\n       * in `entryComponents` have to be inlined.\n       */\n    function (moduleType) { throw _throwError(); };\n    /**\n     * Compiles the given NgModule and all of its components\n     */\n    /**\n       * Compiles the given NgModule and all of its components\n       */\n    Compiler.prototype.compileModuleAsync = /**\n       * Compiles the given NgModule and all of its components\n       */\n    function (moduleType) { throw _throwError(); };\n    /**\n     * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n     */\n    /**\n       * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n       */\n    Compiler.prototype.compileModuleAndAllComponentsSync = /**\n       * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n       */\n    function (moduleType) {\n        throw _throwError();\n    };\n    /**\n     * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n     */\n    /**\n       * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n       */\n    Compiler.prototype.compileModuleAndAllComponentsAsync = /**\n       * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n       */\n    function (moduleType) {\n        throw _throwError();\n    };\n    /**\n     * Clears all caches.\n     */\n    /**\n       * Clears all caches.\n       */\n    Compiler.prototype.clearCache = /**\n       * Clears all caches.\n       */\n    function () { };\n    /**\n     * Clears the cache for the given component/ngModule.\n     */\n    /**\n       * Clears the cache for the given component/ngModule.\n       */\n    Compiler.prototype.clearCacheFor = /**\n       * Clears the cache for the given component/ngModule.\n       */\n    function (type) { };\n    Compiler.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    Compiler.ctorParameters = function () { return []; };\n    return Compiler;\n}());\n/**\n * Token to provide CompilerOptions in the platform injector.\n *\n * @experimental\n */\nvar COMPILER_OPTIONS = new InjectionToken('compilerOptions');\n/**\n * A factory for creating a Compiler\n *\n * @experimental\n */\nvar CompilerFactory = /** @class */ (function () {\n    function CompilerFactory() {\n    }\n    return CompilerFactory;\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 * Represents an instance of a Component created via a {@link ComponentFactory}.\n *\n * `ComponentRef` provides access to the Component Instance as well other objects related to this\n * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}\n * method.\n *\n */\nvar ComponentRef = /** @class */ (function () {\n    function ComponentRef() {\n    }\n    return ComponentRef;\n}());\nvar ComponentFactory = /** @class */ (function () {\n    function ComponentFactory() {\n    }\n    return ComponentFactory;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction noComponentFactoryError(component) {\n    var error = Error(\"No component factory found for \" + stringify(component) + \". Did you add it to @NgModule.entryComponents?\");\n    error[ERROR_COMPONENT] = component;\n    return error;\n}\nvar ERROR_COMPONENT = 'ngComponent';\n\nvar _NullComponentFactoryResolver = /** @class */ (function () {\n    function _NullComponentFactoryResolver() {\n    }\n    _NullComponentFactoryResolver.prototype.resolveComponentFactory = function (component) {\n        throw noComponentFactoryError(component);\n    };\n    return _NullComponentFactoryResolver;\n}());\nvar ComponentFactoryResolver = /** @class */ (function () {\n    function ComponentFactoryResolver() {\n    }\n    ComponentFactoryResolver.NULL = new _NullComponentFactoryResolver();\n    return ComponentFactoryResolver;\n}());\nvar CodegenComponentFactoryResolver = /** @class */ (function () {\n    function CodegenComponentFactoryResolver(factories, _parent, _ngModule) {\n        this._parent = _parent;\n        this._ngModule = _ngModule;\n        this._factories = new Map();\n        for (var i = 0; i < factories.length; i++) {\n            var factory = factories[i];\n            this._factories.set(factory.componentType, factory);\n        }\n    }\n    CodegenComponentFactoryResolver.prototype.resolveComponentFactory = function (component) {\n        var 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    return CodegenComponentFactoryResolver;\n}());\nvar ComponentFactoryBoundToModule = /** @class */ (function (_super) {\n    __extends(ComponentFactoryBoundToModule, _super);\n    function ComponentFactoryBoundToModule(factory, ngModule) {\n        var _this = _super.call(this) || this;\n        _this.factory = factory;\n        _this.ngModule = ngModule;\n        _this.selector = factory.selector;\n        _this.componentType = factory.componentType;\n        _this.ngContentSelectors = factory.ngContentSelectors;\n        _this.inputs = factory.inputs;\n        _this.outputs = factory.outputs;\n        return _this;\n    }\n    ComponentFactoryBoundToModule.prototype.create = function (injector, projectableNodes, rootSelectorOrNode, ngModule) {\n        return this.factory.create(injector, projectableNodes, rootSelectorOrNode, ngModule || this.ngModule);\n    };\n    return ComponentFactoryBoundToModule;\n}(ComponentFactory));\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 * Represents an instance of an NgModule created via a {@link NgModuleFactory}.\n *\n * `NgModuleRef` provides access to the NgModule Instance as well other objects related to this\n * NgModule Instance.\n *\n *\n */\nvar NgModuleRef = /** @class */ (function () {\n    function NgModuleRef() {\n    }\n    return NgModuleRef;\n}());\n/**\n * @experimental\n */\nvar NgModuleFactory = /** @class */ (function () {\n    function NgModuleFactory() {\n    }\n    return NgModuleFactory;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar trace;\nvar events;\nfunction detectWTF() {\n    var wtf = _global /** 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}\nfunction createScope(signature, flags) {\n    if (flags === void 0) { flags = null; }\n    return events.createScope(signature, flags);\n}\nfunction leave(scope, returnValue) {\n    trace.leaveScope(scope, returnValue);\n    return returnValue;\n}\nfunction startTimeRange(rangeType, action) {\n    return trace.beginTimeRange(rangeType, action);\n}\nfunction endTimeRange(range) {\n    trace.endTimeRange(range);\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 * True if WTF is enabled.\n */\nvar wtfEnabled = detectWTF();\nfunction noopScope(arg0, arg1) {\n    return null;\n}\n/**\n * Create trace scope.\n *\n * Scopes must be strictly nested and are analogous to stack frames, but\n * do not have to follow the stack frames. Instead it is recommended that they follow logical\n * nesting. You may want to use\n * [Event\n * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)\n * as they are defined in WTF.\n *\n * Used to mark scope entry. The return value is used to leave the scope.\n *\n *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');\n *\n *     someMethod() {\n *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI\n *        // DO SOME WORK HERE\n *        return wtfLeave(s, 123); // Return value 123\n *     }\n *\n * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can\n * negatively impact the performance of your application. For this reason we recommend that\n * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and\n * so try-finally block has no value. When debugging perf issues, skipping `wtfLeave`, do to\n * exception, will produce incorrect trace, but presence of exception signifies logic error which\n * needs to be fixed before the app should be profiled. Add try-finally only when you expect that\n * an exception is expected during normal execution while profiling.\n *\n * @experimental\n */\nvar wtfCreateScope = wtfEnabled ? createScope : function (signature, flags) { return noopScope; };\n/**\n * Used to mark end of Scope.\n *\n * - `scope` to end.\n * - `returnValue` (optional) to be passed to the WTF.\n *\n * Returns the `returnValue for easy chaining.\n * @experimental\n */\nvar wtfLeave = wtfEnabled ? leave : function (s, r) { return r; };\n/**\n * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.\n * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been\n * enabled.\n *\n *     someMethod() {\n *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');\n *        var future = new Future.delay(5).then((_) {\n *          wtfEndTimeRange(s);\n *        });\n *     }\n * @experimental\n */\nvar wtfStartTimeRange = wtfEnabled ? startTimeRange : function (rangeType, action) { return null; };\n/**\n * Ends a async time range operation.\n * [range] is the return value from [wtfStartTimeRange] Async ranges only work if WTF has been\n * enabled.\n * @experimental\n */\nvar wtfEndTimeRange = wtfEnabled ? endTimeRange : function (r) { return 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 * 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 *\n */\nvar EventEmitter = /** @class */ (function (_super) {\n    __extends(EventEmitter, _super);\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     */\n    function EventEmitter(isAsync) {\n        if (isAsync === void 0) { isAsync = false; }\n        var _this = _super.call(this) || this;\n        _this.__isAsync = isAsync;\n        return _this;\n    }\n    EventEmitter.prototype.emit = function (value) { _super.prototype.next.call(this, value); };\n    EventEmitter.prototype.subscribe = function (generatorOrNext, error, complete) {\n        var schedulerFn;\n        var errorFn = function (err) { return null; };\n        var completeFn = function () { return null; };\n        if (generatorOrNext && typeof generatorOrNext === 'object') {\n            schedulerFn = this.__isAsync ? function (value) {\n                setTimeout(function () { return generatorOrNext.next(value); });\n            } : function (value) { generatorOrNext.next(value); };\n            if (generatorOrNext.error) {\n                errorFn = this.__isAsync ? function (err) { setTimeout(function () { return generatorOrNext.error(err); }); } :\n                    function (err) { generatorOrNext.error(err); };\n            }\n            if (generatorOrNext.complete) {\n                completeFn = this.__isAsync ? function () { setTimeout(function () { return generatorOrNext.complete(); }); } :\n                    function () { generatorOrNext.complete(); };\n            }\n        }\n        else {\n            schedulerFn = this.__isAsync ? function (value) { setTimeout(function () { return generatorOrNext(value); }); } :\n                function (value) { generatorOrNext(value); };\n            if (error) {\n                errorFn =\n                    this.__isAsync ? function (err) { setTimeout(function () { return error(err); }); } : function (err) { error(err); };\n            }\n            if (complete) {\n                completeFn =\n                    this.__isAsync ? function () { setTimeout(function () { return complete(); }); } : function () { complete(); };\n            }\n        }\n        var sink = _super.prototype.subscribe.call(this, schedulerFn, errorFn, completeFn);\n        if (generatorOrNext instanceof rxjs.Subscription) {\n            generatorOrNext.add(sink);\n        }\n        return sink;\n    };\n    return EventEmitter;\n}(rxjs.Subject));\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 * 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 *\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 */\nvar NgZone = /** @class */ (function () {\n    function NgZone(_a) {\n        var _b = _a.enableLongStackTrace, enableLongStackTrace = _b === void 0 ? false : _b;\n        this.hasPendingMicrotasks = false;\n        this.hasPendingMacrotasks = false;\n        /**\n           * Whether there are no outstanding microtasks or macrotasks.\n           */\n        this.isStable = true;\n        /**\n           * Notifies when code enters Angular Zone. This gets fired first on VM Turn.\n           */\n        this.onUnstable = new EventEmitter(false);\n        /**\n           * Notifies when there is no more microtasks enqueued 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           */\n        this.onMicrotaskEmpty = new EventEmitter(false);\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           */\n        this.onStable = new EventEmitter(false);\n        /**\n           * Notifies that an error has been delivered.\n           */\n        this.onError = new EventEmitter(false);\n        if (typeof Zone == 'undefined') {\n            throw new Error(\"In this configuration Angular requires Zone.js\");\n        }\n        Zone.assertZonePatched();\n        var self = this;\n        self._nesting = 0;\n        self._outer = self._inner = Zone.current;\n        if (Zone['wtfZoneSpec']) {\n            self._inner = self._inner.fork(Zone['wtfZoneSpec']);\n        }\n        if (Zone['TaskTrackingZoneSpec']) {\n            self._inner = self._inner.fork(new Zone['TaskTrackingZoneSpec']);\n        }\n        if (enableLongStackTrace && Zone['longStackTraceZoneSpec']) {\n            self._inner = self._inner.fork(Zone['longStackTraceZoneSpec']);\n        }\n        forkInnerZoneWithAngularBehavior(self);\n    }\n    NgZone.isInAngularZone = function () { return Zone.current.get('isAngularZone') === true; };\n    NgZone.assertInAngularZone = function () {\n        if (!NgZone.isInAngularZone()) {\n            throw new Error('Expected to be in Angular Zone, but it is not!');\n        }\n    };\n    NgZone.assertNotInAngularZone = function () {\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     */\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       */\n    NgZone.prototype.run = /**\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       */\n    function (fn, applyThis, applyArgs) {\n        return this._inner.run(fn, applyThis, applyArgs);\n    };\n    /**\n     * Executes the `fn` function synchronously within the Angular zone as a task and returns value\n     * returned by 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     */\n    /**\n       * Executes the `fn` function synchronously within the Angular zone as a task and returns value\n       * returned by 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       */\n    NgZone.prototype.runTask = /**\n       * Executes the `fn` function synchronously within the Angular zone as a task and returns value\n       * returned by 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       */\n    function (fn, applyThis, applyArgs, name) {\n        var zone = this._inner;\n        var task = zone.scheduleEventTask('NgZoneEvent: ' + name, fn, EMPTY_PAYLOAD, noop, noop);\n        try {\n            return zone.runTask(task, applyThis, applyArgs);\n        }\n        finally {\n            zone.cancelTask(task);\n        }\n    };\n    /**\n     * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not\n     * rethrown.\n     */\n    /**\n       * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not\n       * rethrown.\n       */\n    NgZone.prototype.runGuarded = /**\n       * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not\n       * rethrown.\n       */\n    function (fn, applyThis, applyArgs) {\n        return this._inner.runGuarded(fn, applyThis, applyArgs);\n    };\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     */\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       */\n    NgZone.prototype.runOutsideAngular = /**\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       */\n    function (fn) {\n        return this._outer.run(fn);\n    };\n    return NgZone;\n}());\nfunction noop() { }\nvar EMPTY_PAYLOAD = {};\nfunction checkStable(zone) {\n    if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {\n        try {\n            zone._nesting++;\n            zone.onMicrotaskEmpty.emit(null);\n        }\n        finally {\n            zone._nesting--;\n            if (!zone.hasPendingMicrotasks) {\n                try {\n                    zone.runOutsideAngular(function () { return zone.onStable.emit(null); });\n                }\n                finally {\n                    zone.isStable = true;\n                }\n            }\n        }\n    }\n}\nfunction forkInnerZoneWithAngularBehavior(zone) {\n    zone._inner = zone._inner.fork({\n        name: 'angular',\n        properties: { 'isAngularZone': true },\n        onInvokeTask: function (delegate, current, target, task, applyThis, applyArgs) {\n            try {\n                onEnter(zone);\n                return delegate.invokeTask(target, task, applyThis, applyArgs);\n            }\n            finally {\n                onLeave(zone);\n            }\n        },\n        onInvoke: function (delegate, current, target, callback, applyThis, applyArgs, source) {\n            try {\n                onEnter(zone);\n                return delegate.invoke(target, callback, applyThis, applyArgs, source);\n            }\n            finally {\n                onLeave(zone);\n            }\n        },\n        onHasTask: function (delegate, current, target, 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                    zone.hasPendingMicrotasks = hasTaskState.microTask;\n                    checkStable(zone);\n                }\n                else if (hasTaskState.change == 'macroTask') {\n                    zone.hasPendingMacrotasks = hasTaskState.macroTask;\n                }\n            }\n        },\n        onHandleError: function (delegate, current, target, error) {\n            delegate.handleError(target, error);\n            zone.runOutsideAngular(function () { return zone.onError.emit(error); });\n            return false;\n        }\n    });\n}\nfunction onEnter(zone) {\n    zone._nesting++;\n    if (zone.isStable) {\n        zone.isStable = false;\n        zone.onUnstable.emit(null);\n    }\n}\nfunction onLeave(zone) {\n    zone._nesting--;\n    checkStable(zone);\n}\n/**\n * Provides a noop implementation of `NgZone` which does nothing. This zone requires explicit calls\n * to framework to perform rendering.\n */\nvar NoopNgZone = /** @class */ (function () {\n    function NoopNgZone() {\n        this.hasPendingMicrotasks = false;\n        this.hasPendingMacrotasks = false;\n        this.isStable = true;\n        this.onUnstable = new EventEmitter();\n        this.onMicrotaskEmpty = new EventEmitter();\n        this.onStable = new EventEmitter();\n        this.onError = new EventEmitter();\n    }\n    NoopNgZone.prototype.run = function (fn) { return fn(); };\n    NoopNgZone.prototype.runGuarded = function (fn) { return fn(); };\n    NoopNgZone.prototype.runOutsideAngular = function (fn) { return fn(); };\n    NoopNgZone.prototype.runTask = function (fn) { return fn(); };\n    return NoopNgZone;\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 * 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 */\nvar Testability = /** @class */ (function () {\n    function Testability(_ngZone) {\n        var _this = this;\n        this._ngZone = _ngZone;\n        this._pendingCount = 0;\n        this._isZoneStable = 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        this._didWork = false;\n        this._callbacks = [];\n        this._watchAngularEvents();\n        _ngZone.run(function () { _this.taskTrackingZone = Zone.current.get('TaskTrackingZone'); });\n    }\n    Testability.prototype._watchAngularEvents = function () {\n        var _this = this;\n        this._ngZone.onUnstable.subscribe({\n            next: function () {\n                _this._didWork = true;\n                _this._isZoneStable = false;\n            }\n        });\n        this._ngZone.runOutsideAngular(function () {\n            _this._ngZone.onStable.subscribe({\n                next: function () {\n                    NgZone.assertNotInAngularZone();\n                    scheduleMicroTask(function () {\n                        _this._isZoneStable = true;\n                        _this._runCallbacksIfReady();\n                    });\n                }\n            });\n        });\n    };\n    /**\n     * Increases the number of pending request\n     * @deprecated pending requests are now tracked with zones.\n     */\n    /**\n       * Increases the number of pending request\n       * @deprecated pending requests are now tracked with zones.\n       */\n    Testability.prototype.increasePendingRequestCount = /**\n       * Increases the number of pending request\n       * @deprecated pending requests are now tracked with zones.\n       */\n    function () {\n        this._pendingCount += 1;\n        this._didWork = true;\n        return this._pendingCount;\n    };\n    /**\n     * Decreases the number of pending request\n     * @deprecated pending requests are now tracked with zones\n     */\n    /**\n       * Decreases the number of pending request\n       * @deprecated pending requests are now tracked with zones\n       */\n    Testability.prototype.decreasePendingRequestCount = /**\n       * Decreases the number of pending request\n       * @deprecated pending requests are now tracked with zones\n       */\n    function () {\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     * Whether an associated application is stable\n     */\n    /**\n       * Whether an associated application is stable\n       */\n    Testability.prototype.isStable = /**\n       * Whether an associated application is stable\n       */\n    function () {\n        return this._isZoneStable && this._pendingCount === 0 && !this._ngZone.hasPendingMacrotasks;\n    };\n    Testability.prototype._runCallbacksIfReady = function () {\n        var _this = this;\n        if (this.isStable()) {\n            // Schedules the call backs in a new frame so that it is always async.\n            scheduleMicroTask(function () {\n                while (_this._callbacks.length !== 0) {\n                    var cb = (_this._callbacks.pop());\n                    clearTimeout(cb.timeoutId);\n                    cb.doneCb(_this._didWork);\n                }\n                _this._didWork = false;\n            });\n        }\n        else {\n            // Still not stable, send updates.\n            var pending_1 = this.getPendingTasks();\n            this._callbacks = this._callbacks.filter(function (cb) {\n                if (cb.updateCb && cb.updateCb(pending_1)) {\n                    clearTimeout(cb.timeoutId);\n                    return false;\n                }\n                return true;\n            });\n            this._didWork = true;\n        }\n    };\n    Testability.prototype.getPendingTasks = function () {\n        if (!this.taskTrackingZone) {\n            return [];\n        }\n        return this.taskTrackingZone.macroTasks.map(function (t) {\n            return {\n                source: t.source,\n                isPeriodic: t.data.isPeriodic,\n                delay: t.data.delay,\n                // From TaskTrackingZone:\n                // https://github.com/angular/zone.js/blob/master/lib/zone-spec/task-tracking.ts#L40\n                creationLocation: t.creationLocation,\n                // Added by Zones for XHRs\n                // https://github.com/angular/zone.js/blob/master/lib/browser/browser.ts#L133\n                xhr: t.data.target\n            };\n        });\n    };\n    Testability.prototype.addCallback = function (cb, timeout, updateCb) {\n        var _this = this;\n        var timeoutId = -1;\n        if (timeout && timeout > 0) {\n            timeoutId = setTimeout(function () {\n                _this._callbacks = _this._callbacks.filter(function (cb) { return cb.timeoutId !== timeoutId; });\n                cb(_this._didWork, _this.getPendingTasks());\n            }, timeout);\n        }\n        this._callbacks.push({ doneCb: cb, timeoutId: timeoutId, updateCb: updateCb });\n    };\n    /**\n     * Wait for the application to be stable with a timeout. If the timeout is reached before that\n     * happens, the callback receives a list of the macro tasks that were pending, otherwise null.\n     *\n     * @param doneCb The callback to invoke when Angular is stable or the timeout expires\n     *    whichever comes first.\n     * @param timeout Optional. The maximum time to wait for Angular to become stable. If not\n     *    specified, whenStable() will wait forever.\n     * @param updateCb Optional. If specified, this callback will be invoked whenever the set of\n     *    pending macrotasks changes. If this callback returns true doneCb will not be invoked\n     *    and no further updates will be issued.\n     */\n    /**\n       * Wait for the application to be stable with a timeout. If the timeout is reached before that\n       * happens, the callback receives a list of the macro tasks that were pending, otherwise null.\n       *\n       * @param doneCb The callback to invoke when Angular is stable or the timeout expires\n       *    whichever comes first.\n       * @param timeout Optional. The maximum time to wait for Angular to become stable. If not\n       *    specified, whenStable() will wait forever.\n       * @param updateCb Optional. If specified, this callback will be invoked whenever the set of\n       *    pending macrotasks changes. If this callback returns true doneCb will not be invoked\n       *    and no further updates will be issued.\n       */\n    Testability.prototype.whenStable = /**\n       * Wait for the application to be stable with a timeout. If the timeout is reached before that\n       * happens, the callback receives a list of the macro tasks that were pending, otherwise null.\n       *\n       * @param doneCb The callback to invoke when Angular is stable or the timeout expires\n       *    whichever comes first.\n       * @param timeout Optional. The maximum time to wait for Angular to become stable. If not\n       *    specified, whenStable() will wait forever.\n       * @param updateCb Optional. If specified, this callback will be invoked whenever the set of\n       *    pending macrotasks changes. If this callback returns true doneCb will not be invoked\n       *    and no further updates will be issued.\n       */\n    function (doneCb, timeout, updateCb) {\n        if (updateCb && !this.taskTrackingZone) {\n            throw new Error('Task tracking zone is required when passing an update callback to ' +\n                'whenStable(). Is \"zone.js/dist/task-tracking.js\" loaded?');\n        }\n        // These arguments are 'Function' above to keep the public API simple.\n        this.addCallback(doneCb, timeout, updateCb);\n        this._runCallbacksIfReady();\n    };\n    /**\n     * Get the number of pending requests\n     * @deprecated pending requests are now tracked with zones\n     */\n    /**\n       * Get the number of pending requests\n       * @deprecated pending requests are now tracked with zones\n       */\n    Testability.prototype.getPendingRequestCount = /**\n       * Get the number of pending requests\n       * @deprecated pending requests are now tracked with zones\n       */\n    function () { return this._pendingCount; };\n    /**\n     * Find providers by name\n     * @param using The root element to search from\n     * @param provider The name of binding variable\n     * @param exactMatch Whether using exactMatch\n     */\n    /**\n       * Find providers by name\n       * @param using The root element to search from\n       * @param provider The name of binding variable\n       * @param exactMatch Whether using exactMatch\n       */\n    Testability.prototype.findProviders = /**\n       * Find providers by name\n       * @param using The root element to search from\n       * @param provider The name of binding variable\n       * @param exactMatch Whether using exactMatch\n       */\n    function (using, provider, exactMatch) {\n        // TODO(juliemr): implement.\n        return [];\n    };\n    Testability.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    Testability.ctorParameters = function () { return [\n        { type: NgZone, },\n    ]; };\n    return Testability;\n}());\n/**\n * A global registry of {@link Testability} instances for specific elements.\n * @experimental\n */\nvar TestabilityRegistry = /** @class */ (function () {\n    function TestabilityRegistry() {\n        /** @internal */\n        this._applications = new Map();\n        _testabilityGetter.addToWindow(this);\n    }\n    /**\n     * Registers an application with a testability hook so that it can be tracked\n     * @param token token of application, root element\n     * @param testability Testability hook\n     */\n    /**\n       * Registers an application with a testability hook so that it can be tracked\n       * @param token token of application, root element\n       * @param testability Testability hook\n       */\n    TestabilityRegistry.prototype.registerApplication = /**\n       * Registers an application with a testability hook so that it can be tracked\n       * @param token token of application, root element\n       * @param testability Testability hook\n       */\n    function (token, testability) {\n        this._applications.set(token, testability);\n    };\n    /**\n     * Unregisters an application.\n     * @param token token of application, root element\n     */\n    /**\n       * Unregisters an application.\n       * @param token token of application, root element\n       */\n    TestabilityRegistry.prototype.unregisterApplication = /**\n       * Unregisters an application.\n       * @param token token of application, root element\n       */\n    function (token) { this._applications.delete(token); };\n    /**\n     * Unregisters all applications\n     */\n    /**\n       * Unregisters all applications\n       */\n    TestabilityRegistry.prototype.unregisterAllApplications = /**\n       * Unregisters all applications\n       */\n    function () { this._applications.clear(); };\n    /**\n     * Get a testability hook associated with the application\n     * @param elem root element\n     */\n    /**\n       * Get a testability hook associated with the application\n       * @param elem root element\n       */\n    TestabilityRegistry.prototype.getTestability = /**\n       * Get a testability hook associated with the application\n       * @param elem root element\n       */\n    function (elem) { return this._applications.get(elem) || null; };\n    /**\n     * Get all registered testabilities\n     */\n    /**\n       * Get all registered testabilities\n       */\n    TestabilityRegistry.prototype.getAllTestabilities = /**\n       * Get all registered testabilities\n       */\n    function () { return Array.from(this._applications.values()); };\n    /**\n     * Get all registered applications(root elements)\n     */\n    /**\n       * Get all registered applications(root elements)\n       */\n    TestabilityRegistry.prototype.getAllRootElements = /**\n       * Get all registered applications(root elements)\n       */\n    function () { return Array.from(this._applications.keys()); };\n    /**\n     * Find testability of a node in the Tree\n     * @param elem node\n     * @param findInAncestors whether finding testability in ancestors if testability was not found in\n     * current node\n     */\n    /**\n       * Find testability of a node in the Tree\n       * @param elem node\n       * @param findInAncestors whether finding testability in ancestors if testability was not found in\n       * current node\n       */\n    TestabilityRegistry.prototype.findTestabilityInTree = /**\n       * Find testability of a node in the Tree\n       * @param elem node\n       * @param findInAncestors whether finding testability in ancestors if testability was not found in\n       * current node\n       */\n    function (elem, findInAncestors) {\n        if (findInAncestors === void 0) { findInAncestors = true; }\n        return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);\n    };\n    TestabilityRegistry.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    TestabilityRegistry.ctorParameters = function () { return []; };\n    return TestabilityRegistry;\n}());\nvar _NoopGetTestability = /** @class */ (function () {\n    function _NoopGetTestability() {\n    }\n    _NoopGetTestability.prototype.addToWindow = function (registry) { };\n    _NoopGetTestability.prototype.findTestabilityInTree = function (registry, elem, findInAncestors) {\n        return null;\n    };\n    return _NoopGetTestability;\n}());\n/**\n * Set the {@link GetTestability} implementation used by the Angular testing framework.\n * @experimental\n */\nfunction setTestabilityGetter(getter) {\n    _testabilityGetter = getter;\n}\nvar _testabilityGetter = new _NoopGetTestability();\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _devMode = true;\nvar _runModeLocked = false;\nvar _platform;\nvar ALLOW_MULTIPLE_PLATFORMS = new InjectionToken('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 *\n */\nfunction enableProdMode() {\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 */\nfunction isDevMode() {\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 */\nvar NgProbeToken = /** @class */ (function () {\n    function NgProbeToken(name, token) {\n        this.name = name;\n        this.token = token;\n    }\n    return NgProbeToken;\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 */\nfunction createPlatform(injector) {\n    if (_platform && !_platform.destroyed &&\n        !_platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n        throw new Error('There can be only one platform. Destroy the previous one to create a new one.');\n    }\n    _platform = injector.get(PlatformRef);\n    var inits = injector.get(PLATFORM_INITIALIZER, null);\n    if (inits)\n        inits.forEach(function (init) { return 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 */\nfunction createPlatformFactory(parentPlatformFactory, name, providers) {\n    if (providers === void 0) { providers = []; }\n    var desc = \"Platform: \" + name;\n    var marker = new InjectionToken(desc);\n    return function (extraProviders) {\n        if (extraProviders === void 0) { extraProviders = []; }\n        var platform = getPlatform();\n        if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n            if (parentPlatformFactory) {\n                parentPlatformFactory(providers.concat(extraProviders).concat({ provide: marker, useValue: true }));\n            }\n            else {\n                var injectedProviders = providers.concat(extraProviders).concat({ provide: marker, useValue: true });\n                createPlatform(Injector.create({ providers: injectedProviders, name: desc }));\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 */\nfunction assertPlatform(requiredToken) {\n    var platform = getPlatform();\n    if (!platform) {\n        throw new Error('No platform exists!');\n    }\n    if (!platform.injector.get(requiredToken, null)) {\n        throw new Error('A platform with a different configuration has been created. Please destroy it first.');\n    }\n    return platform;\n}\n/**\n * Destroy the existing platform.\n *\n * @experimental APIs related to application bootstrap are currently under review.\n */\nfunction destroyPlatform() {\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 */\nfunction getPlatform() {\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 *\n */\nvar PlatformRef = /** @class */ (function () {\n    /** @internal */\n    function PlatformRef(_injector) {\n        this._injector = _injector;\n        this._modules = [];\n        this._destroyListeners = [];\n        this._destroyed = false;\n    }\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     */\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       */\n    PlatformRef.prototype.bootstrapModuleFactory = /**\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       */\n    function (moduleFactory, options) {\n        var _this = this;\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        var ngZoneOption = options ? options.ngZone : undefined;\n        var ngZone = getNgZone(ngZoneOption);\n        var providers = [{ provide: NgZone, useValue: ngZone }];\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(function () {\n            var ngZoneInjector = Injector.create({ providers: providers, parent: _this.injector, name: moduleFactory.moduleType.name });\n            var moduleRef = moduleFactory.create(ngZoneInjector);\n            var exceptionHandler = moduleRef.injector.get(ErrorHandler, null);\n            if (!exceptionHandler) {\n                throw new Error('No ErrorHandler. Is platform module (BrowserModule) included?');\n            }\n            moduleRef.onDestroy(function () { return remove(_this._modules, moduleRef); });\n            ngZone.runOutsideAngular(function () {\n                return ngZone.onError.subscribe({ next: function (error) { exceptionHandler.handleError(error); } });\n            });\n            return _callAndReportToErrorHandler(exceptionHandler, (ngZone), function () {\n                var initStatus = moduleRef.injector.get(ApplicationInitStatus);\n                initStatus.runInitializers();\n                return initStatus.donePromise.then(function () {\n                    _this._moduleDoBootstrap(moduleRef);\n                    return moduleRef;\n                });\n            });\n        });\n    };\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     *\n     */\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       *\n       */\n    PlatformRef.prototype.bootstrapModule = /**\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       *\n       */\n    function (moduleType, compilerOptions) {\n        var _this = this;\n        if (compilerOptions === void 0) { compilerOptions = []; }\n        var compilerFactory = this.injector.get(CompilerFactory);\n        var options = optionsReducer({}, compilerOptions);\n        var compiler = compilerFactory.createCompiler([options]);\n        return compiler.compileModuleAsync(moduleType)\n            .then(function (moduleFactory) { return _this.bootstrapModuleFactory(moduleFactory, options); });\n    };\n    PlatformRef.prototype._moduleDoBootstrap = function (moduleRef) {\n        var appRef = moduleRef.injector.get(ApplicationRef);\n        if (moduleRef._bootstrapComponents.length > 0) {\n            moduleRef._bootstrapComponents.forEach(function (f) { return appRef.bootstrap(f); });\n        }\n        else if (moduleRef.instance.ngDoBootstrap) {\n            moduleRef.instance.ngDoBootstrap(appRef);\n        }\n        else {\n            throw new Error(\"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    };\n    /**\n     * Register a listener to be called when the platform is disposed.\n     */\n    /**\n       * Register a listener to be called when the platform is disposed.\n       */\n    PlatformRef.prototype.onDestroy = /**\n       * Register a listener to be called when the platform is disposed.\n       */\n    function (callback) { this._destroyListeners.push(callback); };\n    Object.defineProperty(PlatformRef.prototype, \"injector\", {\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         */\n        get: /**\n           * Retrieve the platform {@link Injector}, which is the parent injector for\n           * every Angular application on the page and provides singleton providers.\n           */\n        function () { return this._injector; },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Destroy the Angular platform and all Angular applications on the page.\n     */\n    /**\n       * Destroy the Angular platform and all Angular applications on the page.\n       */\n    PlatformRef.prototype.destroy = /**\n       * Destroy the Angular platform and all Angular applications on the page.\n       */\n    function () {\n        if (this._destroyed) {\n            throw new Error('The platform has already been destroyed!');\n        }\n        this._modules.slice().forEach(function (module) { return module.destroy(); });\n        this._destroyListeners.forEach(function (listener) { return listener(); });\n        this._destroyed = true;\n    };\n    Object.defineProperty(PlatformRef.prototype, \"destroyed\", {\n        get: function () { return this._destroyed; },\n        enumerable: true,\n        configurable: true\n    });\n    PlatformRef.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    PlatformRef.ctorParameters = function () { return [\n        { type: Injector, },\n    ]; };\n    return PlatformRef;\n}());\nfunction getNgZone(ngZoneOption) {\n    var ngZone;\n    if (ngZoneOption === 'noop') {\n        ngZone = new NoopNgZone();\n    }\n    else {\n        ngZone = (ngZoneOption === 'zone.js' ? undefined : ngZoneOption) ||\n            new NgZone({ enableLongStackTrace: isDevMode() });\n    }\n    return ngZone;\n}\nfunction _callAndReportToErrorHandler(errorHandler, ngZone, callback) {\n    try {\n        var result = callback();\n        if (isPromise(result)) {\n            return result.catch(function (e) {\n                ngZone.runOutsideAngular(function () { return errorHandler.handleError(e); });\n                // rethrow as the exception handler might not do it\n                throw e;\n            });\n        }\n        return result;\n    }\n    catch (e) {\n        ngZone.runOutsideAngular(function () { return errorHandler.handleError(e); });\n        // rethrow as the exception handler might not do it\n        throw e;\n    }\n}\nfunction optionsReducer(dst, objs) {\n    if (Array.isArray(objs)) {\n        dst = objs.reduce(optionsReducer, dst);\n    }\n    else {\n        dst = __assign({}, dst, objs);\n    }\n    return dst;\n}\n/**\n * A reference to an Angular application running on a page.\n *\n *\n */\nvar ApplicationRef = /** @class */ (function () {\n    /** @internal */\n    function ApplicationRef(_zone, _console, _injector, _exceptionHandler, _componentFactoryResolver, _initStatus) {\n        var _this = this;\n        this._zone = _zone;\n        this._console = _console;\n        this._injector = _injector;\n        this._exceptionHandler = _exceptionHandler;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._initStatus = _initStatus;\n        this._bootstrapListeners = [];\n        this._views = [];\n        this._runningTick = false;\n        this._enforceNoNewChanges = false;\n        this._stable = true;\n        /**\n           * Get a list of component types registered to this application.\n           * This list is populated even before the component is created.\n           */\n        this.componentTypes = [];\n        /**\n           * Get a list of components registered to this application.\n           */\n        this.components = [];\n        this._enforceNoNewChanges = isDevMode();\n        this._zone.onMicrotaskEmpty.subscribe({ next: function () { _this._zone.run(function () { _this.tick(); }); } });\n        var isCurrentlyStable = new rxjs.Observable(function (observer) {\n            _this._stable = _this._zone.isStable && !_this._zone.hasPendingMacrotasks &&\n                !_this._zone.hasPendingMicrotasks;\n            _this._zone.runOutsideAngular(function () {\n                observer.next(_this._stable);\n                observer.complete();\n            });\n        });\n        var isStable = new rxjs.Observable(function (observer) {\n            // Create the subscription to onStable outside the Angular Zone so that\n            // the callback is run outside the Angular Zone.\n            var stableSub;\n            _this._zone.runOutsideAngular(function () {\n                stableSub = _this._zone.onStable.subscribe(function () {\n                    NgZone.assertNotInAngularZone();\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(function () {\n                        if (!_this._stable && !_this._zone.hasPendingMacrotasks &&\n                            !_this._zone.hasPendingMicrotasks) {\n                            _this._stable = true;\n                            observer.next(true);\n                        }\n                    });\n                });\n            });\n            var unstableSub = _this._zone.onUnstable.subscribe(function () {\n                NgZone.assertInAngularZone();\n                if (_this._stable) {\n                    _this._stable = false;\n                    _this._zone.runOutsideAngular(function () { observer.next(false); });\n                }\n            });\n            return function () {\n                stableSub.unsubscribe();\n                unstableSub.unsubscribe();\n            };\n        });\n        this.isStable =\n            rxjs.merge(isCurrentlyStable, isStable.pipe(operators.share()));\n    }\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     */\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       */\n    ApplicationRef.prototype.bootstrap = /**\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       */\n    function (componentOrFactory, rootSelectorOrNode) {\n        var _this = this;\n        if (!this._initStatus.done) {\n            throw new Error('Cannot bootstrap as there are still asynchronous initializers running. Bootstrap components in the `ngDoBootstrap` method of the root module.');\n        }\n        var componentFactory;\n        if (componentOrFactory instanceof ComponentFactory) {\n            componentFactory = componentOrFactory;\n        }\n        else {\n            componentFactory =\n                (this._componentFactoryResolver.resolveComponentFactory(componentOrFactory));\n        }\n        this.componentTypes.push(componentFactory.componentType);\n        // Create a factory associated with the current module if it's not bound to some other\n        var ngModule = componentFactory instanceof ComponentFactoryBoundToModule ?\n            null :\n            this._injector.get(NgModuleRef);\n        var selectorOrNode = rootSelectorOrNode || componentFactory.selector;\n        var compRef = componentFactory.create(Injector.NULL, [], selectorOrNode, ngModule);\n        compRef.onDestroy(function () { _this._unloadComponent(compRef); });\n        var testability = compRef.injector.get(Testability, null);\n        if (testability) {\n            compRef.injector.get(TestabilityRegistry)\n                .registerApplication(compRef.location.nativeElement, testability);\n        }\n        this._loadComponent(compRef);\n        if (isDevMode()) {\n            this._console.log(\"Angular is running in the development mode. Call enableProdMode() to enable the production mode.\");\n        }\n        return compRef;\n    };\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     */\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       */\n    ApplicationRef.prototype.tick = /**\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       */\n    function () {\n        var _this = this;\n        if (this._runningTick) {\n            throw new Error('ApplicationRef.tick is called recursively');\n        }\n        var scope = ApplicationRef._tickScope();\n        try {\n            this._runningTick = true;\n            this._views.forEach(function (view) { return view.detectChanges(); });\n            if (this._enforceNoNewChanges) {\n                this._views.forEach(function (view) { return view.checkNoChanges(); });\n            }\n        }\n        catch (e) {\n            // Attention: Don't rethrow as it could cancel subscriptions to Observables!\n            this._zone.runOutsideAngular(function () { return _this._exceptionHandler.handleError(e); });\n        }\n        finally {\n            this._runningTick = false;\n            wtfLeave(scope);\n        }\n    };\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     */\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       */\n    ApplicationRef.prototype.attachView = /**\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       */\n    function (viewRef) {\n        var view = viewRef;\n        this._views.push(view);\n        view.attachToAppRef(this);\n    };\n    /**\n     * Detaches a view from dirty checking again.\n     */\n    /**\n       * Detaches a view from dirty checking again.\n       */\n    ApplicationRef.prototype.detachView = /**\n       * Detaches a view from dirty checking again.\n       */\n    function (viewRef) {\n        var view = viewRef;\n        remove(this._views, view);\n        view.detachFromAppRef();\n    };\n    ApplicationRef.prototype._loadComponent = function (componentRef) {\n        this.attachView(componentRef.hostView);\n        this.tick();\n        this.components.push(componentRef);\n        // Get the listeners lazily to prevent DI cycles.\n        var listeners = this._injector.get(APP_BOOTSTRAP_LISTENER, []).concat(this._bootstrapListeners);\n        listeners.forEach(function (listener) { return listener(componentRef); });\n    };\n    ApplicationRef.prototype._unloadComponent = function (componentRef) {\n        this.detachView(componentRef.hostView);\n        remove(this.components, componentRef);\n    };\n    /** @internal */\n    /** @internal */\n    ApplicationRef.prototype.ngOnDestroy = /** @internal */\n    function () {\n        // TODO(alxhub): Dispose of the NgZone.\n        this._views.slice().forEach(function (view) { return view.destroy(); });\n    };\n    Object.defineProperty(ApplicationRef.prototype, \"viewCount\", {\n        /**\n         * Returns the number of attached views.\n         */\n        get: /**\n           * Returns the number of attached views.\n           */\n        function () { return this._views.length; },\n        enumerable: true,\n        configurable: true\n    });\n    /** @internal */\n    ApplicationRef._tickScope = wtfCreateScope('ApplicationRef#tick()');\n    ApplicationRef.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    ApplicationRef.ctorParameters = function () { return [\n        { type: NgZone, },\n        { type: Console, },\n        { type: Injector, },\n        { type: ErrorHandler, },\n        { type: ComponentFactoryResolver, },\n        { type: ApplicationInitStatus, },\n    ]; };\n    return ApplicationRef;\n}());\nfunction remove(list, el) {\n    var index = list.indexOf(el);\n    if (index > -1) {\n        list.splice(index, 1);\n    }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @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 * @deprecated Use `RendererType2` (and `Renderer2`) instead.\n */\nvar RenderComponentType = /** @class */ (function () {\n    function RenderComponentType(id, templateUrl, slotCount, encapsulation, styles, animations) {\n        this.id = id;\n        this.templateUrl = templateUrl;\n        this.slotCount = slotCount;\n        this.encapsulation = encapsulation;\n        this.styles = styles;\n        this.animations = animations;\n    }\n    return RenderComponentType;\n}());\n/**\n * @deprecated Debug info is handeled internally in the view engine now.\n */\nvar RenderDebugInfo = /** @class */ (function () {\n    function RenderDebugInfo() {\n    }\n    return RenderDebugInfo;\n}());\n/**\n * @deprecated Use the `Renderer2` instead.\n */\nvar Renderer = /** @class */ (function () {\n    function Renderer() {\n    }\n    return Renderer;\n}());\nvar Renderer2Interceptor = new InjectionToken('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 setElementProperty} or\n * {@link Renderer#setElementAttribute setElementAttribute} 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 */\nvar RootRenderer = /** @class */ (function () {\n    function RootRenderer() {\n    }\n    return RootRenderer;\n}());\n/**\n * @experimental\n */\nvar RendererFactory2 = /** @class */ (function () {\n    function RendererFactory2() {\n    }\n    return RendererFactory2;\n}());\n/**\n * @experimental\n */\n/**\n * @experimental\n */\n\n/**\n * @experimental\n */\n(function (RendererStyleFlags2) {\n    RendererStyleFlags2[RendererStyleFlags2[\"Important\"] = 1] = \"Important\";\n    RendererStyleFlags2[RendererStyleFlags2[\"DashCase\"] = 2] = \"DashCase\";\n})(exports.RendererStyleFlags2 || (exports.RendererStyleFlags2 = {}));\n/**\n * @experimental\n */\nvar Renderer2 = /** @class */ (function () {\n    function Renderer2() {\n    }\n    return Renderer2;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A wrapper around a native element inside of a View.\n *\n * An `ElementRef` is backed by a render-specific element. In the browser, this is usually a DOM\n * element.\n *\n * @security Permitting direct access to the DOM can make your application more vulnerable to\n * XSS attacks. Carefully review any use of `ElementRef` in your code. For more detail, see the\n * [Security Guide](http://g.co/ng/security).\n *\n *\n */\n// Note: We don't expose things like `Injector`, `ViewContainer`, ... here,\n// i.e. users have to ask for what they need. With that, we can build better analysis tools\n// and could do better codegen in the future.\nvar ElementRef = /** @class */ (function () {\n    function ElementRef(nativeElement) {\n        this.nativeElement = nativeElement;\n    }\n    return ElementRef;\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 * Used to load ng module factories.\n *\n */\nvar NgModuleFactoryLoader = /** @class */ (function () {\n    function NgModuleFactoryLoader() {\n    }\n    return NgModuleFactoryLoader;\n}());\nvar moduleFactories = new Map();\n/**\n * Registers a loaded module. Should only be called from generated NgModuleFactory code.\n * @experimental\n */\nfunction registerModuleFactory(id, factory) {\n    var existing = moduleFactories.get(id);\n    if (existing) {\n        throw new Error(\"Duplicate module registered for \" + id + \" - \" + existing.moduleType.name + \" vs \" + factory.moduleType.name);\n    }\n    moduleFactories.set(id, factory);\n}\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 */\nfunction getModuleFactory(id) {\n    var factory = moduleFactories.get(id);\n    if (!factory)\n        throw new Error(\"No module with ID \" + id + \" loaded\");\n    return factory;\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 * 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 *\n */\nvar QueryList = /** @class */ (function () {\n    function QueryList() {\n        this.dirty = true;\n        this._results = [];\n        this.changes = new EventEmitter();\n        this.length = 0;\n    }\n    /**\n     * See\n     * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n     */\n    /**\n       * See\n       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n       */\n    QueryList.prototype.map = /**\n       * See\n       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n       */\n    function (fn) { 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     */\n    /**\n       * See\n       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n       */\n    QueryList.prototype.filter = /**\n       * See\n       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n       */\n    function (fn) {\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     */\n    /**\n       * See\n       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n       */\n    QueryList.prototype.find = /**\n       * See\n       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n       */\n    function (fn) {\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     */\n    /**\n       * See\n       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n       */\n    QueryList.prototype.reduce = /**\n       * See\n       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n       */\n    function (fn, init) {\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     */\n    /**\n       * See\n       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n       */\n    QueryList.prototype.forEach = /**\n       * See\n       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n       */\n    function (fn) { 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     */\n    /**\n       * See\n       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n       */\n    QueryList.prototype.some = /**\n       * See\n       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n       */\n    function (fn) {\n        return this._results.some(fn);\n    };\n    QueryList.prototype.toArray = function () { return this._results.slice(); };\n    QueryList.prototype[getSymbolIterator()] = function () { return this._results[getSymbolIterator()](); };\n    QueryList.prototype.toString = function () { return this._results.toString(); };\n    QueryList.prototype.reset = function (res) {\n        this._results = flatten(res);\n        this.dirty = false;\n        this.length = this._results.length;\n        this.last = this._results[this.length - 1];\n        this.first = this._results[0];\n    };\n    QueryList.prototype.notifyOnChanges = function () { this.changes.emit(this); };\n    /** internal */\n    /** internal */\n    QueryList.prototype.setDirty = /** internal */\n    function () { this.dirty = true; };\n    /** internal */\n    /** internal */\n    QueryList.prototype.destroy = /** internal */\n    function () {\n        this.changes.complete();\n        this.changes.unsubscribe();\n    };\n    return QueryList;\n}());\nfunction flatten(list) {\n    return list.reduce(function (flat, item) {\n        var flatItem = Array.isArray(item) ? flatten(item) : item;\n        return flat.concat(flatItem);\n    }, []);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _SEPARATOR = '#';\nvar FACTORY_CLASS_SUFFIX = 'NgFactory';\n/**\n * Configuration for SystemJsNgModuleLoader.\n * token.\n *\n * @experimental\n */\nvar SystemJsNgModuleLoaderConfig = /** @class */ (function () {\n    function SystemJsNgModuleLoaderConfig() {\n    }\n    return SystemJsNgModuleLoaderConfig;\n}());\nvar DEFAULT_CONFIG = {\n    factoryPathPrefix: '',\n    factoryPathSuffix: '.ngfactory',\n};\n/**\n * NgModuleFactoryLoader that uses SystemJS to load NgModuleFactory\n * @experimental\n */\nvar SystemJsNgModuleLoader = /** @class */ (function () {\n    function SystemJsNgModuleLoader(_compiler, config) {\n        this._compiler = _compiler;\n        this._config = config || DEFAULT_CONFIG;\n    }\n    SystemJsNgModuleLoader.prototype.load = function (path) {\n        var offlineMode = this._compiler instanceof Compiler;\n        return offlineMode ? this.loadFactory(path) : this.loadAndCompile(path);\n    };\n    SystemJsNgModuleLoader.prototype.loadAndCompile = function (path) {\n        var _this = this;\n        var _a = __read(path.split(_SEPARATOR), 2), module = _a[0], exportName = _a[1];\n        if (exportName === undefined) {\n            exportName = 'default';\n        }\n        return System.import(module)\n            .then(function (module) { return module[exportName]; })\n            .then(function (type) { return checkNotEmpty(type, module, exportName); })\n            .then(function (type) { return _this._compiler.compileModuleAsync(type); });\n    };\n    SystemJsNgModuleLoader.prototype.loadFactory = function (path) {\n        var _a = __read(path.split(_SEPARATOR), 2), module = _a[0], exportName = _a[1];\n        var factoryClassSuffix = FACTORY_CLASS_SUFFIX;\n        if (exportName === undefined) {\n            exportName = 'default';\n            factoryClassSuffix = '';\n        }\n        return System.import(this._config.factoryPathPrefix + module + this._config.factoryPathSuffix)\n            .then(function (module) { return module[exportName + factoryClassSuffix]; })\n            .then(function (factory) { return checkNotEmpty(factory, module, exportName); });\n    };\n    SystemJsNgModuleLoader.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    SystemJsNgModuleLoader.ctorParameters = function () { return [\n        { type: Compiler, },\n        { type: SystemJsNgModuleLoaderConfig, decorators: [{ type: Optional },] },\n    ]; };\n    return SystemJsNgModuleLoader;\n}());\nfunction checkNotEmpty(value, modulePath, exportName) {\n    if (!value) {\n        throw new Error(\"Cannot find '\" + exportName + \"' in '\" + modulePath + \"'\");\n    }\n    return value;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Represents an Embedded Template that can be used to instantiate Embedded Views.\n *\n * You can access a `TemplateRef`, in two ways. Via a directive placed on a `<ng-template>` element\n * (or directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into\n * the constructor of the directive using the `TemplateRef` Token. Alternatively you can query for\n * the `TemplateRef` from a Component or a Directive via {@link Query}.\n *\n * To instantiate Embedded Views based on a Template, use {@link ViewContainerRef#\n * createEmbeddedView}, which will create the View and attach it to the View Container.\n *\n */\nvar TemplateRef = /** @class */ (function () {\n    function TemplateRef() {\n    }\n    return TemplateRef;\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 * 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 *\n */\nvar ViewContainerRef = /** @class */ (function () {\n    function ViewContainerRef() {\n    }\n    return ViewContainerRef;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ChangeDetectorRef = /** @class */ (function () {\n    function ChangeDetectorRef() {\n    }\n    return ChangeDetectorRef;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ViewRef = /** @class */ (function (_super) {\n    __extends(ViewRef, _super);\n    function ViewRef() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return ViewRef;\n}(ChangeDetectorRef));\n/**\n * Represents an Angular View.\n *\n * <!-- TODO: move the next two paragraphs to the dev guide -->\n * A View is a fundamental building block of the application UI. It is the smallest grouping of\n * Elements which are created and destroyed together.\n *\n * Properties of elements in a View can change, but the structure (number and order) of elements in\n * a View cannot. Changing the structure of Elements can only be done by inserting, moving or\n * removing nested Views via a {@link ViewContainerRef}. Each View can contain many View Containers.\n * <!-- /TODO -->\n *\n * ### Example\n *\n * Given this template...\n *\n * ```\n * Count: {{items.length}}\n * <ul>\n *   <li *ngFor=\"let  item of items\">{{item}}</li>\n * </ul>\n * ```\n *\n * We have two {@link TemplateRef}s:\n *\n * Outer {@link TemplateRef}:\n * ```\n * Count: {{items.length}}\n * <ul>\n *   <ng-template ngFor let-item [ngForOf]=\"items\"></ng-template>\n * </ul>\n * ```\n *\n * Inner {@link TemplateRef}:\n * ```\n *   <li>{{item}}</li>\n * ```\n *\n * Notice that the original template is broken down into two separate {@link TemplateRef}s.\n *\n * The outer/inner {@link TemplateRef}s are then assembled into views like so:\n *\n * ```\n * <!-- ViewRef: outer-0 -->\n * Count: 2\n * <ul>\n *   <ng-template view-container-ref></ng-template>\n *   <!-- ViewRef: inner-1 --><li>first</li><!-- /ViewRef: inner-1 -->\n *   <!-- ViewRef: inner-2 --><li>second</li><!-- /ViewRef: inner-2 -->\n * </ul>\n * <!-- /ViewRef: outer-0 -->\n * ```\n * @experimental\n */\nvar EmbeddedViewRef = /** @class */ (function (_super) {\n    __extends(EmbeddedViewRef, _super);\n    function EmbeddedViewRef() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return EmbeddedViewRef;\n}(ViewRef));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar EventListener = /** @class */ (function () {\n    function EventListener(name, callback) {\n        this.name = name;\n        this.callback = callback;\n    }\n    return EventListener;\n}());\n/**\n * @experimental All debugging apis are currently experimental.\n */\nvar DebugNode = /** @class */ (function () {\n    function DebugNode(nativeNode, parent, _debugContext) {\n        this._debugContext = _debugContext;\n        this.nativeNode = nativeNode;\n        if (parent && parent instanceof DebugElement) {\n            parent.addChild(this);\n        }\n        else {\n            this.parent = null;\n        }\n        this.listeners = [];\n    }\n    Object.defineProperty(DebugNode.prototype, \"injector\", {\n        get: function () { return this._debugContext.injector; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"componentInstance\", {\n        get: function () { return this._debugContext.component; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"context\", {\n        get: function () { return this._debugContext.context; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"references\", {\n        get: function () { return this._debugContext.references; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"providerTokens\", {\n        get: function () { return this._debugContext.providerTokens; },\n        enumerable: true,\n        configurable: true\n    });\n    return DebugNode;\n}());\n/**\n * @experimental All debugging apis are currently experimental.\n */\nvar DebugElement = /** @class */ (function (_super) {\n    __extends(DebugElement, _super);\n    function DebugElement(nativeNode, parent, _debugContext) {\n        var _this = _super.call(this, nativeNode, parent, _debugContext) || this;\n        _this.properties = {};\n        _this.attributes = {};\n        _this.classes = {};\n        _this.styles = {};\n        _this.childNodes = [];\n        _this.nativeElement = nativeNode;\n        return _this;\n    }\n    DebugElement.prototype.addChild = function (child) {\n        if (child) {\n            this.childNodes.push(child);\n            child.parent = this;\n        }\n    };\n    DebugElement.prototype.removeChild = function (child) {\n        var childIndex = this.childNodes.indexOf(child);\n        if (childIndex !== -1) {\n            child.parent = null;\n            this.childNodes.splice(childIndex, 1);\n        }\n    };\n    DebugElement.prototype.insertChildrenAfter = function (child, newChildren) {\n        var _this = this;\n        var siblingIndex = this.childNodes.indexOf(child);\n        if (siblingIndex !== -1) {\n            (_a = this.childNodes).splice.apply(_a, __spread([siblingIndex + 1, 0], newChildren));\n            newChildren.forEach(function (c) {\n                if (c.parent) {\n                    c.parent.removeChild(c);\n                }\n                c.parent = _this;\n            });\n        }\n        var _a;\n    };\n    DebugElement.prototype.insertBefore = function (refChild, newChild) {\n        var refIndex = this.childNodes.indexOf(refChild);\n        if (refIndex === -1) {\n            this.addChild(newChild);\n        }\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    DebugElement.prototype.query = function (predicate) {\n        var results = this.queryAll(predicate);\n        return results[0] || null;\n    };\n    DebugElement.prototype.queryAll = function (predicate) {\n        var matches = [];\n        _queryElementChildren(this, predicate, matches);\n        return matches;\n    };\n    DebugElement.prototype.queryAllNodes = function (predicate) {\n        var matches = [];\n        _queryNodeChildren(this, predicate, matches);\n        return matches;\n    };\n    Object.defineProperty(DebugElement.prototype, \"children\", {\n        get: function () {\n            return this.childNodes.filter(function (node) { return node instanceof DebugElement; });\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DebugElement.prototype.triggerEventHandler = function (eventName, eventObj) {\n        this.listeners.forEach(function (listener) {\n            if (listener.name == eventName) {\n                listener.callback(eventObj);\n            }\n        });\n    };\n    return DebugElement;\n}(DebugNode));\n/**\n * @experimental\n */\nfunction asNativeElements(debugEls) {\n    return debugEls.map(function (el) { return el.nativeElement; });\n}\nfunction _queryElementChildren(element, predicate, matches) {\n    element.childNodes.forEach(function (node) {\n        if (node instanceof DebugElement) {\n            if (predicate(node)) {\n                matches.push(node);\n            }\n            _queryElementChildren(node, predicate, matches);\n        }\n    });\n}\nfunction _queryNodeChildren(parentNode, predicate, matches) {\n    if (parentNode instanceof DebugElement) {\n        parentNode.childNodes.forEach(function (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// Need to keep the nodes in a global Map so that multiple angular apps are supported.\nvar _nativeNodeToDebugNode = new Map();\n/**\n * @experimental\n */\nfunction getDebugNode(nativeNode) {\n    return _nativeNodeToDebugNode.get(nativeNode) || null;\n}\n\nfunction indexDebugNode(node) {\n    _nativeNodeToDebugNode.set(node.nativeNode, node);\n}\nfunction removeDebugNodeFromIndex(node) {\n    _nativeNodeToDebugNode.delete(node.nativeNode);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction devModeEqual(a, b) {\n    var isListLikeIterableA = isListLikeIterable(a);\n    var isListLikeIterableB = isListLikeIterable(b);\n    if (isListLikeIterableA && isListLikeIterableB) {\n        return areIterablesEqual(a, b, devModeEqual);\n    }\n    else {\n        var isAObject = a && (typeof a === 'object' || typeof a === 'function');\n        var isBObject = b && (typeof b === 'object' || typeof b === 'function');\n        if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {\n            return true;\n        }\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 has not changed.\n *\n * Wrapped values are unwrapped automatically during the change detection, and the unwrapped value\n * is 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 *\n */\nvar WrappedValue = /** @class */ (function () {\n    function WrappedValue(value) {\n        this.wrapped = value;\n    }\n    /** Creates a wrapped value. */\n    /** Creates a wrapped value. */\n    WrappedValue.wrap = /** Creates a wrapped value. */\n    function (value) { return new WrappedValue(value); };\n    /**\n     * Returns the underlying value of a wrapped value.\n     * Returns the given `value` when it is not wrapped.\n     **/\n    /**\n       * Returns the underlying value of a wrapped value.\n       * Returns the given `value` when it is not wrapped.\n       **/\n    WrappedValue.unwrap = /**\n       * Returns the underlying value of a wrapped value.\n       * Returns the given `value` when it is not wrapped.\n       **/\n    function (value) { return WrappedValue.isWrapped(value) ? value.wrapped : value; };\n    /** Returns true if `value` is a wrapped value. */\n    /** Returns true if `value` is a wrapped value. */\n    WrappedValue.isWrapped = /** Returns true if `value` is a wrapped value. */\n    function (value) { return value instanceof WrappedValue; };\n    return WrappedValue;\n}());\n/**\n * Represents a basic change from a previous to a new value.\n *\n */\nvar SimpleChange = /** @class */ (function () {\n    function SimpleChange(previousValue, currentValue, firstChange) {\n        this.previousValue = previousValue;\n        this.currentValue = currentValue;\n        this.firstChange = firstChange;\n    }\n    /**\n     * Check whether the new value is the first value assigned.\n     */\n    /**\n       * Check whether the new value is the first value assigned.\n       */\n    SimpleChange.prototype.isFirstChange = /**\n       * Check whether the new value is the first value assigned.\n       */\n    function () { return this.firstChange; };\n    return SimpleChange;\n}());\nfunction isListLikeIterable(obj) {\n    if (!isJsObject(obj))\n        return false;\n    return Array.isArray(obj) ||\n        (!(obj instanceof Map) && // JS Map are iterables but return entries as [k, v]\n            // JS Map are iterables but return entries as [k, v]\n            getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop\n}\nfunction areIterablesEqual(a, b, comparator) {\n    var iterator1 = a[getSymbolIterator()]();\n    var iterator2 = b[getSymbolIterator()]();\n    while (true) {\n        var item1 = iterator1.next();\n        var item2 = iterator2.next();\n        if (item1.done && item2.done)\n            return true;\n        if (item1.done || item2.done)\n            return false;\n        if (!comparator(item1.value, item2.value))\n            return false;\n    }\n}\nfunction iterateListLike(obj, fn) {\n    if (Array.isArray(obj)) {\n        for (var i = 0; i < obj.length; i++) {\n            fn(obj[i]);\n        }\n    }\n    else {\n        var iterator = obj[getSymbolIterator()]();\n        var item = void 0;\n        while (!((item = iterator.next()).done)) {\n            fn(item.value);\n        }\n    }\n}\nfunction isJsObject(o) {\n    return o !== null && (typeof o === 'function' || typeof o === 'object');\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar DefaultIterableDifferFactory = /** @class */ (function () {\n    function DefaultIterableDifferFactory() {\n    }\n    DefaultIterableDifferFactory.prototype.supports = function (obj) { return isListLikeIterable(obj); };\n    DefaultIterableDifferFactory.prototype.create = function (trackByFn) {\n        return new DefaultIterableDiffer(trackByFn);\n    };\n    return DefaultIterableDifferFactory;\n}());\nvar trackByIdentity = function (index, item) { return item; };\n/**\n * @deprecated v4.0.0 - Should not be part of public API.\n */\nvar DefaultIterableDiffer = /** @class */ (function () {\n    function DefaultIterableDiffer(trackByFn) {\n        this.length = 0;\n        // Keeps track of the used records at any point in time (during & across `_check()` calls)\n        this._linkedRecords = null;\n        // Keeps track of the removed records at any point in time during `_check()` calls.\n        this._unlinkedRecords = null;\n        this._previousItHead = null;\n        this._itHead = null;\n        this._itTail = null;\n        this._additionsHead = null;\n        this._additionsTail = null;\n        this._movesHead = null;\n        this._movesTail = null;\n        this._removalsHead = null;\n        this._removalsTail = null;\n        // Keeps track of records where custom track by is the same, but item identity has changed\n        this._identityChangesHead = null;\n        this._identityChangesTail = null;\n        this._trackByFn = trackByFn || trackByIdentity;\n    }\n    DefaultIterableDiffer.prototype.forEachItem = function (fn) {\n        var record;\n        for (record = this._itHead; record !== null; record = record._next) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachOperation = function (fn) {\n        var nextIt = this._itHead;\n        var nextRemove = this._removalsHead;\n        var addRemoveOffset = 0;\n        var moveOffsets = null;\n        while (nextIt || nextRemove) {\n            // Figure out which is the next record to process\n            // Order: remove, add, move\n            var record = !nextRemove ||\n                nextIt &&\n                    (nextIt.currentIndex) <\n                        getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?\n                nextIt :\n                nextRemove;\n            var adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);\n            var currentIndex = record.currentIndex;\n            // consume the item, and adjust the addRemoveOffset and update moveDistance if necessary\n            if (record === nextRemove) {\n                addRemoveOffset--;\n                nextRemove = nextRemove._nextRemoved;\n            }\n            else {\n                nextIt = nextIt._next;\n                if (record.previousIndex == null) {\n                    addRemoveOffset++;\n                }\n                else {\n                    // INVARIANT:  currentIndex < previousIndex\n                    if (!moveOffsets)\n                        moveOffsets = [];\n                    var localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;\n                    var localCurrentIndex = (currentIndex) - addRemoveOffset;\n                    if (localMovePreviousIndex != localCurrentIndex) {\n                        for (var i = 0; i < localMovePreviousIndex; i++) {\n                            var offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);\n                            var index = offset + i;\n                            if (localCurrentIndex <= index && index < localMovePreviousIndex) {\n                                moveOffsets[i] = offset + 1;\n                            }\n                        }\n                        var previousIndex = record.previousIndex;\n                        moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;\n                    }\n                }\n            }\n            if (adjPreviousIndex !== currentIndex) {\n                fn(record, adjPreviousIndex, currentIndex);\n            }\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachPreviousItem = function (fn) {\n        var record;\n        for (record = this._previousItHead; record !== null; record = record._nextPrevious) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachAddedItem = function (fn) {\n        var record;\n        for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachMovedItem = function (fn) {\n        var record;\n        for (record = this._movesHead; record !== null; record = record._nextMoved) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachRemovedItem = function (fn) {\n        var record;\n        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachIdentityChange = function (fn) {\n        var record;\n        for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.diff = function (collection) {\n        if (collection == null)\n            collection = [];\n        if (!isListLikeIterable(collection)) {\n            throw new Error(\"Error trying to diff '\" + stringify(collection) + \"'. Only arrays and iterables are allowed\");\n        }\n        if (this.check(collection)) {\n            return this;\n        }\n        else {\n            return null;\n        }\n    };\n    DefaultIterableDiffer.prototype.onDestroy = function () { };\n    DefaultIterableDiffer.prototype.check = function (collection) {\n        var _this = this;\n        this._reset();\n        var record = this._itHead;\n        var mayBeDirty = false;\n        var index;\n        var item;\n        var itemTrackBy;\n        if (Array.isArray(collection)) {\n            this.length = collection.length;\n            for (var index_1 = 0; index_1 < this.length; index_1++) {\n                item = collection[index_1];\n                itemTrackBy = this._trackByFn(index_1, item);\n                if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {\n                    record = this._mismatch(record, item, itemTrackBy, index_1);\n                    mayBeDirty = true;\n                }\n                else {\n                    if (mayBeDirty) {\n                        // TODO(misko): can we limit this to duplicates only?\n                        record = this._verifyReinsertion(record, item, itemTrackBy, index_1);\n                    }\n                    if (!looseIdentical(record.item, item))\n                        this._addIdentityChange(record, item);\n                }\n                record = record._next;\n            }\n        }\n        else {\n            index = 0;\n            iterateListLike(collection, function (item) {\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                }\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))\n                        _this._addIdentityChange(record, item);\n                }\n                record = record._next;\n                index++;\n            });\n            this.length = index;\n        }\n        this._truncate(record);\n        this.collection = collection;\n        return this.isDirty;\n    };\n    Object.defineProperty(DefaultIterableDiffer.prototype, \"isDirty\", {\n        /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity\n         * changes.\n         */\n        get: /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity\n           * changes.\n           */\n        function () {\n            return this._additionsHead !== null || this._movesHead !== null ||\n                this._removalsHead !== null || this._identityChangesHead !== null;\n        },\n        enumerable: true,\n        configurable: true\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     */\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       */\n    DefaultIterableDiffer.prototype._reset = /**\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       */\n    function () {\n        if (this.isDirty) {\n            var record = void 0;\n            var nextRecord = void 0;\n            for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {\n                record._nextPrevious = record._next;\n            }\n            for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n                record.previousIndex = record.currentIndex;\n            }\n            this._additionsHead = this._additionsTail = null;\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            // 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     */\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       */\n    DefaultIterableDiffer.prototype._mismatch = /**\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       */\n    function (record, item, itemTrackBy, index) {\n        // The previous record after which we will append the current one.\n        var previousRecord;\n        if (record === null) {\n            previousRecord = this._itTail;\n        }\n        else {\n            previousRecord = record._prev;\n            // Remove the record from the collection since we know it does not match the item.\n            this._remove(record);\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))\n                this._addIdentityChange(record, item);\n            this._moveAfter(record, previousRecord, index);\n        }\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))\n                    this._addIdentityChange(record, item);\n                this._reinsertAfter(record, previousRecord, index);\n            }\n            else {\n                // It is a new item: add it.\n                record =\n                    this._addAfter(new IterableChangeRecord_(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     */\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       */\n    DefaultIterableDiffer.prototype._verifyReinsertion = /**\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       */\n    function (record, item, itemTrackBy, index) {\n        var reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);\n        if (reinsertRecord !== null) {\n            record = this._reinsertAfter(reinsertRecord, (record._prev), index);\n        }\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     */\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       */\n    DefaultIterableDiffer.prototype._truncate = /**\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       */\n    function (record) {\n        // Anything after that needs to be removed;\n        while (record !== null) {\n            var nextRecord = record._next;\n            this._addToRemovals(this._unlink(record));\n            record = nextRecord;\n        }\n        if (this._unlinkedRecords !== null) {\n            this._unlinkedRecords.clear();\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    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._reinsertAfter = /** @internal */\n    function (record, prevRecord, index) {\n        if (this._unlinkedRecords !== null) {\n            this._unlinkedRecords.remove(record);\n        }\n        var prev = record._prevRemoved;\n        var next = record._nextRemoved;\n        if (prev === null) {\n            this._removalsHead = next;\n        }\n        else {\n            prev._nextRemoved = next;\n        }\n        if (next === null) {\n            this._removalsTail = prev;\n        }\n        else {\n            next._prevRemoved = prev;\n        }\n        this._insertAfter(record, prevRecord, index);\n        this._addToMoves(record, index);\n        return record;\n    };\n    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._moveAfter = /** @internal */\n    function (record, prevRecord, index) {\n        this._unlink(record);\n        this._insertAfter(record, prevRecord, index);\n        this._addToMoves(record, index);\n        return record;\n    };\n    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._addAfter = /** @internal */\n    function (record, prevRecord, index) {\n        this._insertAfter(record, prevRecord, index);\n        if (this._additionsTail === null) {\n            // TODO(vicb):\n            // assert(this._additionsHead === null);\n            this._additionsTail = this._additionsHead = record;\n        }\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    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._insertAfter = /** @internal */\n    function (record, prevRecord, index) {\n        // TODO(vicb):\n        // assert(record != prevRecord);\n        // assert(record._next === null);\n        // assert(record._prev === null);\n        var next = 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        }\n        else {\n            next._prev = record;\n        }\n        if (prevRecord === null) {\n            this._itHead = record;\n        }\n        else {\n            prevRecord._next = record;\n        }\n        if (this._linkedRecords === null) {\n            this._linkedRecords = new _DuplicateMap();\n        }\n        this._linkedRecords.put(record);\n        record.currentIndex = index;\n        return record;\n    };\n    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._remove = /** @internal */\n    function (record) {\n        return this._addToRemovals(this._unlink(record));\n    };\n    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._unlink = /** @internal */\n    function (record) {\n        if (this._linkedRecords !== null) {\n            this._linkedRecords.remove(record);\n        }\n        var prev = record._prev;\n        var next = record._next;\n        // TODO(vicb):\n        // assert((record._prev = null) === null);\n        // assert((record._next = null) === null);\n        if (prev === null) {\n            this._itHead = next;\n        }\n        else {\n            prev._next = next;\n        }\n        if (next === null) {\n            this._itTail = prev;\n        }\n        else {\n            next._prev = prev;\n        }\n        return record;\n    };\n    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._addToMoves = /** @internal */\n    function (record, toIndex) {\n        // TODO(vicb):\n        // assert(record._nextMoved === null);\n        if (record.previousIndex === toIndex) {\n            return record;\n        }\n        if (this._movesTail === null) {\n            // TODO(vicb):\n            // assert(_movesHead === null);\n            this._movesTail = this._movesHead = record;\n        }\n        else {\n            // TODO(vicb):\n            // assert(_movesTail._nextMoved === null);\n            this._movesTail = this._movesTail._nextMoved = record;\n        }\n        return record;\n    };\n    DefaultIterableDiffer.prototype._addToRemovals = function (record) {\n        if (this._unlinkedRecords === null) {\n            this._unlinkedRecords = new _DuplicateMap();\n        }\n        this._unlinkedRecords.put(record);\n        record.currentIndex = null;\n        record._nextRemoved = null;\n        if (this._removalsTail === null) {\n            // TODO(vicb):\n            // assert(_removalsHead === null);\n            this._removalsTail = this._removalsHead = record;\n            record._prevRemoved = null;\n        }\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    /** @internal */\n    /** @internal */\n    DefaultIterableDiffer.prototype._addIdentityChange = /** @internal */\n    function (record, item) {\n        record.item = item;\n        if (this._identityChangesTail === null) {\n            this._identityChangesTail = this._identityChangesHead = record;\n        }\n        else {\n            this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;\n        }\n        return record;\n    };\n    return DefaultIterableDiffer;\n}());\nvar IterableChangeRecord_ = /** @class */ (function () {\n    function IterableChangeRecord_(item, trackById) {\n        this.item = item;\n        this.trackById = trackById;\n        this.currentIndex = null;\n        this.previousIndex = null;\n        /** @internal */\n        this._nextPrevious = null;\n        /** @internal */\n        this._prev = null;\n        /** @internal */\n        this._next = null;\n        /** @internal */\n        this._prevDup = null;\n        /** @internal */\n        this._nextDup = null;\n        /** @internal */\n        this._prevRemoved = null;\n        /** @internal */\n        this._nextRemoved = null;\n        /** @internal */\n        this._nextAdded = null;\n        /** @internal */\n        this._nextMoved = null;\n        /** @internal */\n        this._nextIdentityChange = null;\n    }\n    return IterableChangeRecord_;\n}());\n// A linked list of CollectionChangeRecords with the same IterableChangeRecord_.item\nvar _DuplicateItemRecordList = /** @class */ (function () {\n    function _DuplicateItemRecordList() {\n        /** @internal */\n        this._head = null;\n        /** @internal */\n        this._tail = null;\n    }\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     */\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       */\n    _DuplicateItemRecordList.prototype.add = /**\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       */\n    function (record) {\n        if (this._head === null) {\n            this._head = this._tail = record;\n            record._nextDup = null;\n            record._prevDup = null;\n        }\n        else {\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            // 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    // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and\n    // IterableChangeRecord_.currentIndex >= atOrAfterIndex\n    // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and\n    // IterableChangeRecord_.currentIndex >= atOrAfterIndex\n    _DuplicateItemRecordList.prototype.get = \n    // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and\n    // IterableChangeRecord_.currentIndex >= atOrAfterIndex\n    function (trackById, atOrAfterIndex) {\n        var record;\n        for (record = this._head; record !== null; record = record._nextDup) {\n            if ((atOrAfterIndex === null || atOrAfterIndex <= (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     */\n    /**\n       * Remove one {@link IterableChangeRecord_} from the list of duplicates.\n       *\n       * Returns whether the list of duplicates is empty.\n       */\n    _DuplicateItemRecordList.prototype.remove = /**\n       * Remove one {@link IterableChangeRecord_} from the list of duplicates.\n       *\n       * Returns whether the list of duplicates is empty.\n       */\n    function (record) {\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        var prev = record._prevDup;\n        var next = record._nextDup;\n        if (prev === null) {\n            this._head = next;\n        }\n        else {\n            prev._nextDup = next;\n        }\n        if (next === null) {\n            this._tail = prev;\n        }\n        else {\n            next._prevDup = prev;\n        }\n        return this._head === null;\n    };\n    return _DuplicateItemRecordList;\n}());\nvar _DuplicateMap = /** @class */ (function () {\n    function _DuplicateMap() {\n        this.map = new Map();\n    }\n    _DuplicateMap.prototype.put = function (record) {\n        var key = record.trackById;\n        var duplicates = this.map.get(key);\n        if (!duplicates) {\n            duplicates = new _DuplicateItemRecordList();\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 `atOrAfterIndex` 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 second `a`.\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 `atOrAfterIndex` 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 second `a`.\n       */\n    _DuplicateMap.prototype.get = /**\n       * Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we\n       * have already iterated over, we use the `atOrAfterIndex` 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 second `a`.\n       */\n    function (trackById, atOrAfterIndex) {\n        var key = trackById;\n        var recordList = this.map.get(key);\n        return recordList ? recordList.get(trackById, atOrAfterIndex) : 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     */\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       */\n    _DuplicateMap.prototype.remove = /**\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       */\n    function (record) {\n        var key = record.trackById;\n        var recordList = (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    Object.defineProperty(_DuplicateMap.prototype, \"isEmpty\", {\n        get: function () { return this.map.size === 0; },\n        enumerable: true,\n        configurable: true\n    });\n    _DuplicateMap.prototype.clear = function () { this.map.clear(); };\n    return _DuplicateMap;\n}());\nfunction getPreviousIndex(item, addRemoveOffset, moveOffsets) {\n    var previousIndex = item.previousIndex;\n    if (previousIndex === null)\n        return previousIndex;\n    var moveOffset = 0;\n    if (moveOffsets && previousIndex < moveOffsets.length) {\n        moveOffset = moveOffsets[previousIndex];\n    }\n    return previousIndex + addRemoveOffset + moveOffset;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar DefaultKeyValueDifferFactory = /** @class */ (function () {\n    function DefaultKeyValueDifferFactory() {\n    }\n    DefaultKeyValueDifferFactory.prototype.supports = function (obj) { return obj instanceof Map || isJsObject(obj); };\n    DefaultKeyValueDifferFactory.prototype.create = function () { return new DefaultKeyValueDiffer(); };\n    return DefaultKeyValueDifferFactory;\n}());\nvar DefaultKeyValueDiffer = /** @class */ (function () {\n    function DefaultKeyValueDiffer() {\n        this._records = new Map();\n        this._mapHead = null;\n        // _appendAfter is used in the check loop\n        this._appendAfter = null;\n        this._previousMapHead = null;\n        this._changesHead = null;\n        this._changesTail = null;\n        this._additionsHead = null;\n        this._additionsTail = null;\n        this._removalsHead = null;\n        this._removalsTail = null;\n    }\n    Object.defineProperty(DefaultKeyValueDiffer.prototype, \"isDirty\", {\n        get: function () {\n            return this._additionsHead !== null || this._changesHead !== null ||\n                this._removalsHead !== null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DefaultKeyValueDiffer.prototype.forEachItem = function (fn) {\n        var record;\n        for (record = this._mapHead; record !== null; record = record._next) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachPreviousItem = function (fn) {\n        var record;\n        for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachChangedItem = function (fn) {\n        var record;\n        for (record = this._changesHead; record !== null; record = record._nextChanged) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachAddedItem = function (fn) {\n        var record;\n        for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachRemovedItem = function (fn) {\n        var record;\n        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.diff = function (map) {\n        if (!map) {\n            map = new Map();\n        }\n        else if (!(map instanceof Map || isJsObject(map))) {\n            throw new Error(\"Error trying to diff '\" + stringify(map) + \"'. Only maps and objects are allowed\");\n        }\n        return this.check(map) ? this : null;\n    };\n    DefaultKeyValueDiffer.prototype.onDestroy = function () { };\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     */\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       */\n    DefaultKeyValueDiffer.prototype.check = /**\n       * Check the current state of the map vs the previous.\n       * The algorithm is optimised for when the keys do no change.\n       */\n    function (map) {\n        var _this = this;\n        this._reset();\n        var insertBefore = this._mapHead;\n        this._appendAfter = null;\n        this._forEach(map, function (value, key) {\n            if (insertBefore && insertBefore.key === key) {\n                _this._maybeAddToChanges(insertBefore, value);\n                _this._appendAfter = insertBefore;\n                insertBefore = insertBefore._next;\n            }\n            else {\n                var record = _this._getOrCreateRecordForKey(key, value);\n                insertBefore = _this._insertBeforeOrAppend(insertBefore, record);\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            this._removalsHead = insertBefore;\n            for (var record = insertBefore; record !== null; 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        // Make sure tails have no next records from previous runs\n        if (this._changesTail)\n            this._changesTail._nextChanged = null;\n        if (this._additionsTail)\n            this._additionsTail._nextAdded = null;\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     */\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       */\n    DefaultKeyValueDiffer.prototype._insertBeforeOrAppend = /**\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       */\n    function (before, record) {\n        if (before) {\n            var 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            this._appendAfter = before;\n            return before;\n        }\n        if (this._appendAfter) {\n            this._appendAfter._next = record;\n            record._prev = this._appendAfter;\n        }\n        else {\n            this._mapHead = record;\n        }\n        this._appendAfter = record;\n        return null;\n    };\n    DefaultKeyValueDiffer.prototype._getOrCreateRecordForKey = function (key, value) {\n        if (this._records.has(key)) {\n            var record_1 = (this._records.get(key));\n            this._maybeAddToChanges(record_1, value);\n            var prev = record_1._prev;\n            var next = record_1._next;\n            if (prev) {\n                prev._next = next;\n            }\n            if (next) {\n                next._prev = prev;\n            }\n            record_1._next = null;\n            record_1._prev = null;\n            return record_1;\n        }\n        var record = new KeyValueChangeRecord_(key);\n        this._records.set(key, record);\n        record.currentValue = value;\n        this._addToAdditions(record);\n        return record;\n    };\n    /** @internal */\n    /** @internal */\n    DefaultKeyValueDiffer.prototype._reset = /** @internal */\n    function () {\n        if (this.isDirty) {\n            var record = void 0;\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            // 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            this._changesHead = this._changesTail = null;\n            this._additionsHead = this._additionsTail = null;\n            this._removalsHead = null;\n        }\n    };\n    // Add the record or a given key to the list of changes only when the value has actually changed\n    // Add the record or a given key to the list of changes only when the value has actually changed\n    DefaultKeyValueDiffer.prototype._maybeAddToChanges = \n    // Add the record or a given key to the list of changes only when the value has actually changed\n    function (record, newValue) {\n        if (!looseIdentical(newValue, record.currentValue)) {\n            record.previousValue = record.currentValue;\n            record.currentValue = newValue;\n            this._addToChanges(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype._addToAdditions = function (record) {\n        if (this._additionsHead === null) {\n            this._additionsHead = this._additionsTail = record;\n        }\n        else {\n            this._additionsTail._nextAdded = record;\n            this._additionsTail = record;\n        }\n    };\n    DefaultKeyValueDiffer.prototype._addToChanges = function (record) {\n        if (this._changesHead === null) {\n            this._changesHead = this._changesTail = record;\n        }\n        else {\n            this._changesTail._nextChanged = record;\n            this._changesTail = record;\n        }\n    };\n    /** @internal */\n    /** @internal */\n    DefaultKeyValueDiffer.prototype._forEach = /** @internal */\n    function (obj, fn) {\n        if (obj instanceof Map) {\n            obj.forEach(fn);\n        }\n        else {\n            Object.keys(obj).forEach(function (k) { return fn(obj[k], k); });\n        }\n    };\n    return DefaultKeyValueDiffer;\n}());\nvar KeyValueChangeRecord_ = /** @class */ (function () {\n    function KeyValueChangeRecord_(key) {\n        this.key = key;\n        this.previousValue = null;\n        this.currentValue = null;\n        /** @internal */\n        this._nextPrevious = null;\n        /** @internal */\n        this._next = null;\n        /** @internal */\n        this._prev = null;\n        /** @internal */\n        this._nextAdded = null;\n        /** @internal */\n        this._nextRemoved = null;\n        /** @internal */\n        this._nextChanged = null;\n    }\n    return KeyValueChangeRecord_;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.\n *\n */\nvar IterableDiffers = /** @class */ (function () {\n    function IterableDiffers(factories) {\n        this.factories = factories;\n    }\n    IterableDiffers.create = function (factories, parent) {\n        if (parent != null) {\n            var copied = parent.factories.slice();\n            factories = factories.concat(copied);\n        }\n        return new IterableDiffers(factories);\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     */\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       */\n    IterableDiffers.extend = /**\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       */\n    function (factories) {\n        return {\n            provide: IterableDiffers,\n            useFactory: function (parent) {\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    IterableDiffers.prototype.find = function (iterable) {\n        var factory = this.factories.find(function (f) { return f.supports(iterable); });\n        if (factory != null) {\n            return factory;\n        }\n        else {\n            throw new Error(\"Cannot find a differ supporting object '\" + iterable + \"' of type '\" + getTypeNameForDebugging(iterable) + \"'\");\n        }\n    };\n    IterableDiffers.ngInjectableDef = defineInjectable({\n        providedIn: 'root',\n        factory: function () { return new IterableDiffers([new DefaultIterableDifferFactory()]); }\n    });\n    return IterableDiffers;\n}());\nfunction getTypeNameForDebugging(type) {\n    return type['name'] || typeof type;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.\n *\n */\nvar KeyValueDiffers = /** @class */ (function () {\n    function KeyValueDiffers(factories) {\n        this.factories = factories;\n    }\n    KeyValueDiffers.create = function (factories, parent) {\n        if (parent) {\n            var 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     */\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       */\n    KeyValueDiffers.extend = /**\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       */\n    function (factories) {\n        return {\n            provide: KeyValueDiffers,\n            useFactory: function (parent) {\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    KeyValueDiffers.prototype.find = function (kv) {\n        var factory = this.factories.find(function (f) { return f.supports(kv); });\n        if (factory) {\n            return factory;\n        }\n        throw new Error(\"Cannot find a differ supporting object '\" + kv + \"'\");\n    };\n    return KeyValueDiffers;\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 * Structural diffing for `Object`s and `Map`s.\n */\nvar keyValDiff = [new DefaultKeyValueDifferFactory()];\n/**\n * Structural diffing for `Iterable` types such as `Array`s.\n */\nvar iterableDiff = [new DefaultIterableDifferFactory()];\nvar defaultIterableDiffers = new IterableDiffers(iterableDiff);\nvar defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _CORE_PLATFORM_PROVIDERS = [\n    // Set a default platform name for platforms that don't set it explicitly.\n    { provide: PLATFORM_ID, useValue: 'unknown' },\n    { provide: PlatformRef, deps: [Injector] },\n    { provide: TestabilityRegistry, deps: [] },\n    { provide: Console, deps: [] },\n];\n/**\n * This platform has to be included in any other platform\n *\n * @experimental\n */\nvar platformCore = createPlatformFactory(null, 'core', _CORE_PLATFORM_PROVIDERS);\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 * Provide this token to set the locale of your application.\n * It is used for i18n extraction, by i18n pipes (DatePipe, I18nPluralPipe, CurrencyPipe,\n * DecimalPipe and PercentPipe) and by ICU expressions.\n *\n * See the {@linkDocs guide/i18n#setting-up-locale i18n guide} for more information.\n *\n * ### Example\n *\n * ```typescript\n * import { LOCALE_ID } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   providers: [{provide: LOCALE_ID, useValue: 'en-US' }]\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\nvar LOCALE_ID = new InjectionToken('LocaleId');\n/**\n * Use this token at bootstrap to provide the content of your translation file (`xtb`,\n * `xlf` or `xlf2`) when you want to translate your application in another language.\n *\n * See the {@linkDocs guide/i18n#merge i18n guide} for more information.\n *\n * ### Example\n *\n * ```typescript\n * import { TRANSLATIONS } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * // content of your translation file\n * const translations = '....';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   providers: [{provide: TRANSLATIONS, useValue: translations }]\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\nvar TRANSLATIONS = new InjectionToken('Translations');\n/**\n * Provide this token at bootstrap to set the format of your {@link TRANSLATIONS}: `xtb`,\n * `xlf` or `xlf2`.\n *\n * See the {@linkDocs guide/i18n#merge i18n guide} for more information.\n *\n * ### Example\n *\n * ```typescript\n * import { TRANSLATIONS_FORMAT } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   providers: [{provide: TRANSLATIONS_FORMAT, useValue: 'xlf' }]\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\nvar TRANSLATIONS_FORMAT = new InjectionToken('TranslationsFormat');\n/**\n * Use this enum at bootstrap as an option of `bootstrapModule` to define the strategy\n * that the compiler should use in case of missing translations:\n * - Error: throw if you have missing translations.\n * - Warning (default): show a warning in the console and/or shell.\n * - Ignore: do nothing.\n *\n * See the {@linkDocs guide/i18n#missing-translation i18n guide} for more information.\n *\n * ### Example\n * ```typescript\n * import { MissingTranslationStrategy } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   missingTranslation: MissingTranslationStrategy.Error\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\n/**\n * Use this enum at bootstrap as an option of `bootstrapModule` to define the strategy\n * that the compiler should use in case of missing translations:\n * - Error: throw if you have missing translations.\n * - Warning (default): show a warning in the console and/or shell.\n * - Ignore: do nothing.\n *\n * See the {@linkDocs guide/i18n#missing-translation i18n guide} for more information.\n *\n * ### Example\n * ```typescript\n * import { MissingTranslationStrategy } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   missingTranslation: MissingTranslationStrategy.Error\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\n\n/**\n * Use this enum at bootstrap as an option of `bootstrapModule` to define the strategy\n * that the compiler should use in case of missing translations:\n * - Error: throw if you have missing translations.\n * - Warning (default): show a warning in the console and/or shell.\n * - Ignore: do nothing.\n *\n * See the {@linkDocs guide/i18n#missing-translation i18n guide} for more information.\n *\n * ### Example\n * ```typescript\n * import { MissingTranslationStrategy } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   missingTranslation: MissingTranslationStrategy.Error\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\n(function (MissingTranslationStrategy) {\n    MissingTranslationStrategy[MissingTranslationStrategy[\"Error\"] = 0] = \"Error\";\n    MissingTranslationStrategy[MissingTranslationStrategy[\"Warning\"] = 1] = \"Warning\";\n    MissingTranslationStrategy[MissingTranslationStrategy[\"Ignore\"] = 2] = \"Ignore\";\n})(exports.MissingTranslationStrategy || (exports.MissingTranslationStrategy = {}));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction _iterableDiffersFactory() {\n    return defaultIterableDiffers;\n}\nfunction _keyValueDiffersFactory() {\n    return defaultKeyValueDiffers;\n}\nfunction _localeFactory(locale) {\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 */\nvar ApplicationModule = /** @class */ (function () {\n    // Inject ApplicationRef to make it eager...\n    function ApplicationModule(appRef) {\n    }\n    ApplicationModule.decorators = [\n        { type: NgModule, args: [{\n                    providers: [\n                        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    /** @nocollapse */\n    ApplicationModule.ctorParameters = function () { return [\n        { type: ApplicationRef, },\n    ]; };\n    return ApplicationModule;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This helper class is used to get hold of an inert tree of DOM elements containing dirty HTML\n * that needs sanitizing.\n * Depending upon browser support we must use one of three strategies for doing this.\n * Support: Safari 10.x -> XHR strategy\n * Support: Firefox -> DomParser strategy\n * Default: InertDocument strategy\n */\nvar InertBodyHelper = /** @class */ (function () {\n    function InertBodyHelper(defaultDoc) {\n        this.defaultDoc = defaultDoc;\n        this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');\n        this.inertBodyElement = this.inertDocument.body;\n        if (this.inertBodyElement == null) {\n            // usually there should be only one body element in the document, but IE doesn't have any, so\n            // we need to create one.\n            var inertHtml = this.inertDocument.createElement('html');\n            this.inertDocument.appendChild(inertHtml);\n            this.inertBodyElement = this.inertDocument.createElement('body');\n            inertHtml.appendChild(this.inertBodyElement);\n        }\n        this.inertBodyElement.innerHTML = '<svg><g onload=\"this.parentNode.remove()\"></g></svg>';\n        if (this.inertBodyElement.querySelector && !this.inertBodyElement.querySelector('svg')) {\n            // We just hit the Safari 10.1 bug - which allows JS to run inside the SVG G element\n            // so use the XHR strategy.\n            this.getInertBodyElement = this.getInertBodyElement_XHR;\n            return;\n        }\n        this.inertBodyElement.innerHTML =\n            '<svg><p><style><img src=\"</style><img src=x onerror=alert(1)//\">';\n        if (this.inertBodyElement.querySelector && this.inertBodyElement.querySelector('svg img')) {\n            // We just hit the Firefox bug - which prevents the inner img JS from being sanitized\n            // so use the DOMParser strategy, if it is available.\n            // If the DOMParser is not available then we are not in Firefox (Server/WebWorker?) so we\n            // fall through to the default strategy below.\n            if (isDOMParserAvailable()) {\n                this.getInertBodyElement = this.getInertBodyElement_DOMParser;\n                return;\n            }\n        }\n        // None of the bugs were hit so it is safe for us to use the default InertDocument strategy\n        this.getInertBodyElement = this.getInertBodyElement_InertDocument;\n    }\n    /**\n     * Use XHR to create and fill an inert body element (on Safari 10.1)\n     * See\n     * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449\n     */\n    /**\n       * Use XHR to create and fill an inert body element (on Safari 10.1)\n       * See\n       * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449\n       */\n    InertBodyHelper.prototype.getInertBodyElement_XHR = /**\n       * Use XHR to create and fill an inert body element (on Safari 10.1)\n       * See\n       * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449\n       */\n    function (html) {\n        // We add these extra elements to ensure that the rest of the content is parsed as expected\n        // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the\n        // `<head>` tag.\n        html = '<body><remove></remove>' + html + '</body>';\n        try {\n            html = encodeURI(html);\n        }\n        catch (e) {\n            return null;\n        }\n        var xhr = new XMLHttpRequest();\n        xhr.responseType = 'document';\n        xhr.open('GET', 'data:text/html;charset=utf-8,' + html, false);\n        xhr.send(null);\n        var body = xhr.response.body;\n        body.removeChild((body.firstChild));\n        return body;\n    };\n    /**\n     * Use DOMParser to create and fill an inert body element (on Firefox)\n     * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7\n     *\n     */\n    /**\n       * Use DOMParser to create and fill an inert body element (on Firefox)\n       * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7\n       *\n       */\n    InertBodyHelper.prototype.getInertBodyElement_DOMParser = /**\n       * Use DOMParser to create and fill an inert body element (on Firefox)\n       * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7\n       *\n       */\n    function (html) {\n        // We add these extra elements to ensure that the rest of the content is parsed as expected\n        // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the\n        // `<head>` tag.\n        html = '<body><remove></remove>' + html + '</body>';\n        try {\n            var body = new window\n                .DOMParser()\n                .parseFromString(html, 'text/html')\n                .body;\n            body.removeChild((body.firstChild));\n            return body;\n        }\n        catch (e) {\n            return null;\n        }\n    };\n    /**\n     * Use an HTML5 `template` element, if supported, or an inert body element created via\n     * `createHtmlDocument` to create and fill an inert DOM element.\n     * This is the default sane strategy to use if the browser does not require one of the specialised\n     * strategies above.\n     */\n    /**\n       * Use an HTML5 `template` element, if supported, or an inert body element created via\n       * `createHtmlDocument` to create and fill an inert DOM element.\n       * This is the default sane strategy to use if the browser does not require one of the specialised\n       * strategies above.\n       */\n    InertBodyHelper.prototype.getInertBodyElement_InertDocument = /**\n       * Use an HTML5 `template` element, if supported, or an inert body element created via\n       * `createHtmlDocument` to create and fill an inert DOM element.\n       * This is the default sane strategy to use if the browser does not require one of the specialised\n       * strategies above.\n       */\n    function (html) {\n        // Prefer using <template> element if supported.\n        var templateEl = this.inertDocument.createElement('template');\n        if ('content' in templateEl) {\n            templateEl.innerHTML = html;\n            return templateEl;\n        }\n        this.inertBodyElement.innerHTML = html;\n        // Support: IE 9-11 only\n        // strip custom-namespaced attributes on IE<=11\n        if (this.defaultDoc.documentMode) {\n            this.stripCustomNsAttrs(this.inertBodyElement);\n        }\n        return this.inertBodyElement;\n    };\n    /**\n     * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'\n     * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.\n     * 'ns1:xlink:foo').\n     *\n     * This is undesirable since we don't want to allow any of these custom attributes. This method\n     * strips them all.\n     */\n    /**\n       * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'\n       * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.\n       * 'ns1:xlink:foo').\n       *\n       * This is undesirable since we don't want to allow any of these custom attributes. This method\n       * strips them all.\n       */\n    InertBodyHelper.prototype.stripCustomNsAttrs = /**\n       * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'\n       * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.\n       * 'ns1:xlink:foo').\n       *\n       * This is undesirable since we don't want to allow any of these custom attributes. This method\n       * strips them all.\n       */\n    function (el) {\n        var elAttrs = el.attributes;\n        // loop backwards so that we can support removals.\n        for (var i = elAttrs.length - 1; 0 < i; i--) {\n            var attrib = elAttrs.item(i);\n            var attrName = attrib.name;\n            if (attrName === 'xmlns:ns1' || attrName.indexOf('ns1:') === 0) {\n                el.removeAttribute(attrName);\n            }\n        }\n        var childNode = el.firstChild;\n        while (childNode) {\n            if (childNode.nodeType === Node.ELEMENT_NODE)\n                this.stripCustomNsAttrs(childNode);\n            childNode = childNode.nextSibling;\n        }\n    };\n    return InertBodyHelper;\n}());\n/**\n * We need to determine whether the DOMParser exists in the global context.\n * The try-catch is because, on some browsers, trying to access this property\n * on window can actually throw an error.\n *\n * @suppress {uselessCode}\n */\nfunction isDOMParserAvailable() {\n    try {\n        return !!window.DOMParser;\n    }\n    catch (e) {\n        return false;\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 * A pattern that recognizes a commonly useful subset of URLs that are safe.\n *\n * This regular expression matches a subset of URLs that will not cause script\n * execution if used in URL context within a HTML document. Specifically, this\n * regular expression matches if (comment from here on and regex copied from\n * Soy's EscapingConventions):\n * (1) Either a protocol in a whitelist (http, https, mailto or ftp).\n * (2) or no protocol.  A protocol must be followed by a colon. The below\n *     allows that by allowing colons only after one of the characters [/?#].\n *     A colon after a hash (#) must be in the fragment.\n *     Otherwise, a colon after a (?) must be in a query.\n *     Otherwise, a colon after a single solidus (/) must be in a path.\n *     Otherwise, a colon after a double solidus (//) must be in the authority\n *     (before port).\n *\n * The pattern disallows &, used in HTML entity declarations before\n * one of the characters in [/?#]. This disallows HTML entities used in the\n * protocol name, which should never happen, e.g. \"h&#116;tp\" for \"http\".\n * It also disallows HTML entities in the first path part of a relative path,\n * e.g. \"foo&lt;bar/baz\".  Our existing escaping functions should not produce\n * that. More importantly, it disallows masking of a colon,\n * e.g. \"javascript&#58;...\".\n *\n * This regular expression was taken from the Closure sanitization library.\n */\nvar SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi;\n/** A pattern that matches safe data URLs. Only matches image, video and audio types. */\nvar DATA_URL_PATTERN = /^data:(?:image\\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\\/(?:mpeg|mp4|ogg|webm)|audio\\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+\\/]+=*$/i;\nfunction _sanitizeUrl(url) {\n    url = String(url);\n    if (url.match(SAFE_URL_PATTERN) || url.match(DATA_URL_PATTERN))\n        return url;\n    if (isDevMode()) {\n        console.warn(\"WARNING: sanitizing unsafe URL value \" + url + \" (see http://g.co/ng/security#xss)\");\n    }\n    return 'unsafe:' + url;\n}\nfunction sanitizeSrcset(srcset) {\n    srcset = String(srcset);\n    return srcset.split(',').map(function (srcset) { return _sanitizeUrl(srcset.trim()); }).join(', ');\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction tagSet(tags) {\n    var res = {};\n    try {\n        for (var _a = __values(tags.split(',')), _b = _a.next(); !_b.done; _b = _a.next()) {\n            var t = _b.value;\n            res[t] = true;\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n    return res;\n    var e_1, _c;\n}\nfunction merge$1() {\n    var sets = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sets[_i] = arguments[_i];\n    }\n    var res = {};\n    try {\n        for (var sets_1 = __values(sets), sets_1_1 = sets_1.next(); !sets_1_1.done; sets_1_1 = sets_1.next()) {\n            var s = sets_1_1.value;\n            for (var v in s) {\n                if (s.hasOwnProperty(v))\n                    res[v] = true;\n            }\n        }\n    }\n    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n    finally {\n        try {\n            if (sets_1_1 && !sets_1_1.done && (_a = sets_1.return)) _a.call(sets_1);\n        }\n        finally { if (e_2) throw e_2.error; }\n    }\n    return res;\n    var e_2, _a;\n}\n// Good source of info about elements and attributes\n// http://dev.w3.org/html5/spec/Overview.html#semantics\n// http://simon.html5.org/html-elements\n// Safe Void Elements - HTML5\n// http://dev.w3.org/html5/spec/Overview.html#void-elements\nvar VOID_ELEMENTS = tagSet('area,br,col,hr,img,wbr');\n// Elements that you can, intentionally, leave open (and which close themselves)\n// http://dev.w3.org/html5/spec/Overview.html#optional-tags\nvar OPTIONAL_END_TAG_BLOCK_ELEMENTS = tagSet('colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr');\nvar OPTIONAL_END_TAG_INLINE_ELEMENTS = tagSet('rp,rt');\nvar OPTIONAL_END_TAG_ELEMENTS = merge$1(OPTIONAL_END_TAG_INLINE_ELEMENTS, OPTIONAL_END_TAG_BLOCK_ELEMENTS);\n// Safe Block Elements - HTML5\nvar BLOCK_ELEMENTS = merge$1(OPTIONAL_END_TAG_BLOCK_ELEMENTS, tagSet('address,article,' +\n    'aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,' +\n    'h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul'));\n// Inline Elements - HTML5\nvar INLINE_ELEMENTS = merge$1(OPTIONAL_END_TAG_INLINE_ELEMENTS, tagSet('a,abbr,acronym,audio,b,' +\n    'bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,' +\n    'samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video'));\nvar VALID_ELEMENTS = merge$1(VOID_ELEMENTS, BLOCK_ELEMENTS, INLINE_ELEMENTS, OPTIONAL_END_TAG_ELEMENTS);\n// Attributes that have href and hence need to be sanitized\nvar URI_ATTRS = tagSet('background,cite,href,itemtype,longdesc,poster,src,xlink:href');\n// Attributes that have special href set hence need to be sanitized\nvar SRCSET_ATTRS = tagSet('srcset');\nvar HTML_ATTRS = tagSet('abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,' +\n    'compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,' +\n    'ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,' +\n    'scope,scrolling,shape,size,sizes,span,srclang,start,summary,tabindex,target,title,translate,type,usemap,' +\n    'valign,value,vspace,width');\n// NB: This currently consciously doesn't support SVG. SVG sanitization has had several security\n// issues in the past, so it seems safer to leave it out if possible. If support for binding SVG via\n// innerHTML is required, SVG attributes should be added here.\n// NB: Sanitization does not allow <form> elements or other active elements (<button> etc). Those\n// can be sanitized, but they increase security surface area without a legitimate use case, so they\n// are left out here.\nvar VALID_ATTRS = merge$1(URI_ATTRS, SRCSET_ATTRS, HTML_ATTRS);\n/**\n * SanitizingHtmlSerializer serializes a DOM fragment, stripping out any unsafe elements and unsafe\n * attributes.\n */\nvar SanitizingHtmlSerializer = /** @class */ (function () {\n    function SanitizingHtmlSerializer() {\n        // Explicitly track if something was stripped, to avoid accidentally warning of sanitization just\n        // because characters were re-encoded.\n        this.sanitizedSomething = false;\n        this.buf = [];\n    }\n    SanitizingHtmlSerializer.prototype.sanitizeChildren = function (el) {\n        // This cannot use a TreeWalker, as it has to run on Angular's various DOM adapters.\n        // However this code never accesses properties off of `document` before deleting its contents\n        // again, so it shouldn't be vulnerable to DOM clobbering.\n        var current = (el.firstChild);\n        while (current) {\n            if (current.nodeType === Node.ELEMENT_NODE) {\n                this.startElement(current);\n            }\n            else if (current.nodeType === Node.TEXT_NODE) {\n                this.chars((current.nodeValue));\n            }\n            else {\n                // Strip non-element, non-text nodes.\n                this.sanitizedSomething = true;\n            }\n            if (current.firstChild) {\n                current = (current.firstChild);\n                continue;\n            }\n            while (current) {\n                // Leaving the element. Walk up and to the right, closing tags as we go.\n                if (current.nodeType === Node.ELEMENT_NODE) {\n                    this.endElement(current);\n                }\n                var next = this.checkClobberedElement(current, (current.nextSibling));\n                if (next) {\n                    current = next;\n                    break;\n                }\n                current = this.checkClobberedElement(current, (current.parentNode));\n            }\n        }\n        return this.buf.join('');\n    };\n    SanitizingHtmlSerializer.prototype.startElement = function (element) {\n        var tagName = element.nodeName.toLowerCase();\n        if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {\n            this.sanitizedSomething = true;\n            return;\n        }\n        this.buf.push('<');\n        this.buf.push(tagName);\n        var elAttrs = element.attributes;\n        for (var i = 0; i < elAttrs.length; i++) {\n            var elAttr = elAttrs.item(i);\n            var attrName = elAttr.name;\n            var lower = attrName.toLowerCase();\n            if (!VALID_ATTRS.hasOwnProperty(lower)) {\n                this.sanitizedSomething = true;\n                continue;\n            }\n            var value = elAttr.value;\n            // TODO(martinprobst): Special case image URIs for data:image/...\n            if (URI_ATTRS[lower])\n                value = _sanitizeUrl(value);\n            if (SRCSET_ATTRS[lower])\n                value = sanitizeSrcset(value);\n            this.buf.push(' ', attrName, '=\"', encodeEntities(value), '\"');\n        }\n        this.buf.push('>');\n    };\n    SanitizingHtmlSerializer.prototype.endElement = function (current) {\n        var tagName = current.nodeName.toLowerCase();\n        if (VALID_ELEMENTS.hasOwnProperty(tagName) && !VOID_ELEMENTS.hasOwnProperty(tagName)) {\n            this.buf.push('</');\n            this.buf.push(tagName);\n            this.buf.push('>');\n        }\n    };\n    SanitizingHtmlSerializer.prototype.chars = function (chars) { this.buf.push(encodeEntities(chars)); };\n    SanitizingHtmlSerializer.prototype.checkClobberedElement = function (node, nextNode) {\n        if (nextNode &&\n            (node.compareDocumentPosition(nextNode) &\n                Node.DOCUMENT_POSITION_CONTAINED_BY) === Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            throw new Error(\"Failed to sanitize html because the element is clobbered: \" + node.outerHTML);\n        }\n        return nextNode;\n    };\n    return SanitizingHtmlSerializer;\n}());\n// Regular Expressions for parsing tags and attributes\nvar SURROGATE_PAIR_REGEXP = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g;\n// ! to ~ is the ASCII range.\nvar NON_ALPHANUMERIC_REGEXP = /([^\\#-~ |!])/g;\n/**\n * Escapes all potentially dangerous characters, so that the\n * resulting string can be safely inserted into attribute or\n * element text.\n * @param value\n */\nfunction encodeEntities(value) {\n    return value.replace(/&/g, '&amp;')\n        .replace(SURROGATE_PAIR_REGEXP, function (match) {\n        var hi = match.charCodeAt(0);\n        var low = match.charCodeAt(1);\n        return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';\n    })\n        .replace(NON_ALPHANUMERIC_REGEXP, function (match) { return '&#' + match.charCodeAt(0) + ';'; })\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;');\n}\nvar inertBodyHelper;\n/**\n * Sanitizes the given unsafe, untrusted HTML fragment, and returns HTML text that is safe to add to\n * the DOM in a browser environment.\n */\nfunction _sanitizeHtml(defaultDoc, unsafeHtmlInput) {\n    var inertBodyElement = null;\n    try {\n        inertBodyHelper = inertBodyHelper || new InertBodyHelper(defaultDoc);\n        // Make sure unsafeHtml is actually a string (TypeScript types are not enforced at runtime).\n        var unsafeHtml = unsafeHtmlInput ? String(unsafeHtmlInput) : '';\n        inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);\n        // mXSS protection. Repeatedly parse the document to make sure it stabilizes, so that a browser\n        // trying to auto-correct incorrect HTML cannot cause formerly inert HTML to become dangerous.\n        var mXSSAttempts = 5;\n        var parsedHtml = unsafeHtml;\n        do {\n            if (mXSSAttempts === 0) {\n                throw new Error('Failed to sanitize html because the input is unstable');\n            }\n            mXSSAttempts--;\n            unsafeHtml = parsedHtml;\n            parsedHtml = inertBodyElement.innerHTML;\n            inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);\n        } while (unsafeHtml !== parsedHtml);\n        var sanitizer = new SanitizingHtmlSerializer();\n        var safeHtml = sanitizer.sanitizeChildren(getTemplateContent((inertBodyElement)) || inertBodyElement);\n        if (isDevMode() && sanitizer.sanitizedSomething) {\n            console.warn('WARNING: sanitizing HTML stripped some content (see http://g.co/ng/security#xss).');\n        }\n        return safeHtml;\n    }\n    finally {\n        // In case anything goes wrong, clear out inertElement to reset the entire DOM structure.\n        if (inertBodyElement) {\n            var parent_1 = getTemplateContent(inertBodyElement) || inertBodyElement;\n            while (parent_1.firstChild) {\n                parent_1.removeChild(parent_1.firstChild);\n            }\n        }\n    }\n}\nfunction getTemplateContent(el) {\n    return 'content' in el /** Microsoft/TypeScript#21517 */ && isTemplateElement(el) ?\n        el.content :\n        null;\n}\nfunction isTemplateElement(el) {\n    return el.nodeType === Node.ELEMENT_NODE && el.nodeName === 'TEMPLATE';\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 * Regular expression for safe style values.\n *\n * Quotes (\" and ') are allowed, but a check must be done elsewhere to ensure they're balanced.\n *\n * ',' allows multiple values to be assigned to the same property (e.g. background-attachment or\n * font-family) and hence could allow multiple values to get injected, but that should pose no risk\n * of XSS.\n *\n * The function expression checks only for XSS safety, not for CSS validity.\n *\n * This regular expression was taken from the Closure sanitization library, and augmented for\n * transformation values.\n */\nvar VALUES = '[-,.\"\\'%_!# a-zA-Z0-9]+';\nvar TRANSFORMATION_FNS = '(?:matrix|translate|scale|rotate|skew|perspective)(?:X|Y|3d)?';\nvar COLOR_FNS = '(?:rgb|hsl)a?';\nvar GRADIENTS = '(?:repeating-)?(?:linear|radial)-gradient';\nvar CSS3_FNS = '(?:calc|attr)';\nvar FN_ARGS = '\\\\([-0-9.%, #a-zA-Z]+\\\\)';\nvar SAFE_STYLE_VALUE = new RegExp(\"^(\" + VALUES + \"|\" +\n    (\"(?:\" + TRANSFORMATION_FNS + \"|\" + COLOR_FNS + \"|\" + GRADIENTS + \"|\" + CSS3_FNS + \")\") +\n    (FN_ARGS + \")$\"), 'g');\n/**\n * Matches a `url(...)` value with an arbitrary argument as long as it does\n * not contain parentheses.\n *\n * The URL value still needs to be sanitized separately.\n *\n * `url(...)` values are a very common use case, e.g. for `background-image`. With carefully crafted\n * CSS style rules, it is possible to construct an information leak with `url` values in CSS, e.g.\n * by observing whether scroll bars are displayed, or character ranges used by a font face\n * definition.\n *\n * Angular only allows binding CSS values (as opposed to entire CSS rules), so it is unlikely that\n * binding a URL value without further cooperation from the page will cause an information leak, and\n * if so, it is just a leak, not a full blown XSS vulnerability.\n *\n * Given the common use case, low likelihood of attack vector, and low impact of an attack, this\n * code is permissive and allows URLs that sanitize otherwise.\n */\nvar URL_RE = /^url\\(([^)]+)\\)$/;\n/**\n * Checks that quotes (\" and ') are properly balanced inside a string. Assumes\n * that neither escape (\\) nor any other character that could result in\n * breaking out of a string parsing context are allowed;\n * see http://www.w3.org/TR/css3-syntax/#string-token-diagram.\n *\n * This code was taken from the Closure sanitization library.\n */\nfunction hasBalancedQuotes(value) {\n    var outsideSingle = true;\n    var outsideDouble = true;\n    for (var i = 0; i < value.length; i++) {\n        var c = value.charAt(i);\n        if (c === '\\'' && outsideDouble) {\n            outsideSingle = !outsideSingle;\n        }\n        else if (c === '\"' && outsideSingle) {\n            outsideDouble = !outsideDouble;\n        }\n    }\n    return outsideSingle && outsideDouble;\n}\n/**\n * Sanitizes the given untrusted CSS style property value (i.e. not an entire object, just a single\n * value) and returns a value that is safe to use in a browser environment.\n */\nfunction _sanitizeStyle(value) {\n    value = String(value).trim(); // Make sure it's actually a string.\n    if (!value)\n        return '';\n    // Single url(...) values are supported, but only for URLs that sanitize cleanly. See above for\n    // reasoning behind this.\n    var urlMatch = value.match(URL_RE);\n    if ((urlMatch && _sanitizeUrl(urlMatch[1]) === urlMatch[1]) ||\n        value.match(SAFE_STYLE_VALUE) && hasBalancedQuotes(value)) {\n        return value; // Safe style values.\n    }\n    if (isDevMode()) {\n        console.warn(\"WARNING: sanitizing unsafe style value \" + value + \" (see http://g.co/ng/security#xss).\");\n    }\n    return 'unsafe';\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 * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property\n * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly\n * handled.\n *\n * See DomSanitizer for more details on security in Angular applications.\n *\n *\n */\n/**\n * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property\n * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly\n * handled.\n *\n * See DomSanitizer for more details on security in Angular applications.\n *\n *\n */\n\n/**\n * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property\n * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly\n * handled.\n *\n * See DomSanitizer for more details on security in Angular applications.\n *\n *\n */\n(function (SecurityContext) {\n    SecurityContext[SecurityContext[\"NONE\"] = 0] = \"NONE\";\n    SecurityContext[SecurityContext[\"HTML\"] = 1] = \"HTML\";\n    SecurityContext[SecurityContext[\"STYLE\"] = 2] = \"STYLE\";\n    SecurityContext[SecurityContext[\"SCRIPT\"] = 3] = \"SCRIPT\";\n    SecurityContext[SecurityContext[\"URL\"] = 4] = \"URL\";\n    SecurityContext[SecurityContext[\"RESOURCE_URL\"] = 5] = \"RESOURCE_URL\";\n})(exports.SecurityContext || (exports.SecurityContext = {}));\n/**\n * Sanitizer is used by the views to sanitize potentially dangerous values.\n *\n *\n */\nvar Sanitizer = /** @class */ (function () {\n    function Sanitizer() {\n    }\n    return Sanitizer;\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// Called before each cycle of a view's check to detect whether this is in the\n// initState for which we need to call ngOnInit, ngAfterContentInit or ngAfterViewInit\n// lifecycle methods. Returns true if this check cycle should call lifecycle\n// methods.\nfunction shiftInitState(view, priorInitState, newInitState) {\n    // Only update the InitState if we are currently in the prior state.\n    // For example, only move into CallingInit if we are in BeforeInit. Only\n    // move into CallingContentInit if we are in CallingInit. Normally this will\n    // always be true because of how checkCycle is called in checkAndUpdateView.\n    // However, if checkAndUpdateView is called recursively or if an exception is\n    // thrown while checkAndUpdateView is running, checkAndUpdateView starts over\n    // from the beginning. This ensures the state is monotonically increasing,\n    // terminating in the AfterInit state, which ensures the Init methods are called\n    // at least once and only once.\n    var state = view.state;\n    var initState = state & 1792;\n    if (initState === priorInitState) {\n        view.state = (state & ~1792 /* InitState_Mask */) | newInitState;\n        view.initIndex = -1;\n        return true;\n    }\n    return initState === newInitState;\n}\n// Returns true if the lifecycle init method should be called for the node with\n// the given init index.\nfunction shouldCallLifecycleInitHook(view, initState, index) {\n    if ((view.state & 1792 /* InitState_Mask */) === initState && view.initIndex <= index) {\n        view.initIndex = index + 1;\n        return true;\n    }\n    return false;\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asTextData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asElementData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asProviderData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asPureExpressionData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asQueryList(view, index) {\n    return view.nodes[index];\n}\nvar DebugContext = /** @class */ (function () {\n    function DebugContext() {\n    }\n    return DebugContext;\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 */\nvar Services = {\n    setCurrentNode: (undefined),\n    createRootView: (undefined),\n    createEmbeddedView: (undefined),\n    createComponentView: (undefined),\n    createNgModuleRef: (undefined),\n    overrideProvider: (undefined),\n    overrideComponentView: (undefined),\n    clearOverrides: (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/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction expressionChangedAfterItHasBeenCheckedError(context, oldValue, currValue, isFirstCheck) {\n    var msg = \"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}\nfunction viewWrappedDebugError(err, context) {\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}\nfunction viewDebugError(msg, context) {\n    var err = new Error(msg);\n    _addDebugContext(err, context);\n    return err;\n}\nfunction _addDebugContext(err, context) {\n    err[ERROR_DEBUG_CONTEXT] = context;\n    err[ERROR_LOGGER] = context.logError.bind(context);\n}\nfunction isViewDebugError(err) {\n    return !!getDebugContext(err);\n}\nfunction viewDestroyedError(action) {\n    return new Error(\"ViewDestroyedError: Attempt to use a destroyed view: \" + action);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NOOP = function () { };\nvar _tokenKeyCache = new Map();\nfunction tokenKey(token) {\n    var key = _tokenKeyCache.get(token);\n    if (!key) {\n        key = stringify(token) + '_' + _tokenKeyCache.size;\n        _tokenKeyCache.set(token, key);\n    }\n    return key;\n}\nfunction unwrapValue(view, nodeIdx, bindingIdx, value) {\n    if (WrappedValue.isWrapped(value)) {\n        value = WrappedValue.unwrap(value);\n        var globalBindingIdx = view.def.nodes[nodeIdx].bindingIndex + bindingIdx;\n        var oldValue = WrappedValue.unwrap(view.oldValues[globalBindingIdx]);\n        view.oldValues[globalBindingIdx] = new WrappedValue(oldValue);\n    }\n    return value;\n}\nvar UNDEFINED_RENDERER_TYPE_ID = '$$undefined';\nvar EMPTY_RENDERER_TYPE_ID = '$$empty';\n// Attention: this function is called as top level function.\n// Putting any logic in here will destroy closure tree shaking!\nfunction createRendererType2(values) {\n    return {\n        id: UNDEFINED_RENDERER_TYPE_ID,\n        styles: values.styles,\n        encapsulation: values.encapsulation,\n        data: values.data\n    };\n}\nvar _renderCompCount = 0;\nfunction resolveRendererType2(type) {\n    if (type && type.id === UNDEFINED_RENDERER_TYPE_ID) {\n        // first time we see this RendererType2. Initialize it...\n        var isFilled = ((type.encapsulation != null && type.encapsulation !== exports.ViewEncapsulation.None) ||\n            type.styles.length || Object.keys(type.data).length);\n        if (isFilled) {\n            type.id = \"c\" + _renderCompCount++;\n        }\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}\nfunction checkBinding(view, def, bindingIdx, value) {\n    var oldValues = view.oldValues;\n    if ((view.state & 2 /* FirstCheck */) ||\n        !looseIdentical(oldValues[def.bindingIndex + bindingIdx], value)) {\n        return true;\n    }\n    return false;\n}\nfunction checkAndUpdateBinding(view, def, bindingIdx, value) {\n    if (checkBinding(view, def, bindingIdx, value)) {\n        view.oldValues[def.bindingIndex + bindingIdx] = value;\n        return true;\n    }\n    return false;\n}\nfunction checkBindingNoChanges(view, def, bindingIdx, value) {\n    var oldValue = view.oldValues[def.bindingIndex + bindingIdx];\n    if ((view.state & 1 /* BeforeFirstCheck */) || !devModeEqual(oldValue, value)) {\n        var bindingName = def.bindings[bindingIdx].name;\n        throw expressionChangedAfterItHasBeenCheckedError(Services.createDebugContext(view, def.nodeIndex), bindingName + \": \" + oldValue, bindingName + \": \" + value, (view.state & 1 /* BeforeFirstCheck */) !== 0);\n    }\n}\nfunction markParentViewsForCheck(view) {\n    var currView = view;\n    while (currView) {\n        if (currView.def.flags & 2 /* OnPush */) {\n            currView.state |= 8 /* ChecksEnabled */;\n        }\n        currView = currView.viewContainerParent || currView.parent;\n    }\n}\nfunction markParentViewsForCheckProjectedViews(view, endView) {\n    var currView = view;\n    while (currView && currView !== endView) {\n        currView.state |= 64 /* CheckProjectedViews */;\n        currView = currView.viewContainerParent || currView.parent;\n    }\n}\nfunction dispatchEvent(view, nodeIndex, eventName, event) {\n    try {\n        var nodeDef = view.def.nodes[nodeIndex];\n        var startView = nodeDef.flags & 33554432 /* ComponentView */ ?\n            asElementData(view, nodeIndex).componentView :\n            view;\n        markParentViewsForCheck(startView);\n        return Services.handleEvent(view, nodeIndex, eventName, event);\n    }\n    catch (e) {\n        // Attention: Don't rethrow, as it would cancel Observable subscriptions!\n        view.root.errorHandler.handleError(e);\n    }\n}\nfunction declaredViewContainer(view) {\n    if (view.parent) {\n        var parentView = view.parent;\n        return asElementData(parentView, view.parentNodeDef.nodeIndex);\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 */\nfunction viewParentEl(view) {\n    var parentView = view.parent;\n    if (parentView) {\n        return view.parentNodeDef.parent;\n    }\n    else {\n        return null;\n    }\n}\nfunction renderNode(view, def) {\n    switch (def.flags & 201347067 /* Types */) {\n        case 1 /* TypeElement */:\n            return asElementData(view, def.nodeIndex).renderElement;\n        case 2 /* TypeText */:\n            return asTextData(view, def.nodeIndex).renderText;\n    }\n}\nfunction elementEventFullName(target, name) {\n    return target ? target + \":\" + name : name;\n}\nfunction isComponentView(view) {\n    return !!view.parent && !!(view.parentNodeDef.flags & 32768 /* Component */);\n}\nfunction isEmbeddedView(view) {\n    return !!view.parent && !(view.parentNodeDef.flags & 32768 /* Component */);\n}\nfunction filterQueryId(queryId) {\n    return 1 << (queryId % 32);\n}\nfunction splitMatchedQueriesDsl(matchedQueriesDsl) {\n    var matchedQueries = {};\n    var matchedQueryIds = 0;\n    var references = {};\n    if (matchedQueriesDsl) {\n        matchedQueriesDsl.forEach(function (_a) {\n            var _b = __read(_a, 2), queryId = _b[0], valueType = _b[1];\n            if (typeof queryId === 'number') {\n                matchedQueries[queryId] = valueType;\n                matchedQueryIds |= filterQueryId(queryId);\n            }\n            else {\n                references[queryId] = valueType;\n            }\n        });\n    }\n    return { matchedQueries: matchedQueries, references: references, matchedQueryIds: matchedQueryIds };\n}\nfunction splitDepsDsl(deps, sourceName) {\n    return deps.map(function (value) {\n        var token;\n        var flags;\n        if (Array.isArray(value)) {\n            _a = __read(value, 2), flags = _a[0], token = _a[1];\n        }\n        else {\n            flags = 0 /* None */;\n            token = value;\n        }\n        if (token && (typeof token === 'function' || typeof token === 'object') && sourceName) {\n            Object.defineProperty(token, SOURCE, { value: sourceName, configurable: true });\n        }\n        return { flags: flags, token: token, tokenKey: tokenKey(token) };\n        var _a;\n    });\n}\nfunction getParentRenderElement(view, renderHost, def) {\n    var renderParent = def.renderParent;\n    if (renderParent) {\n        if ((renderParent.flags & 1 /* TypeElement */) === 0 ||\n            (renderParent.flags & 33554432 /* ComponentView */) === 0 ||\n            (renderParent.element.componentRendererType &&\n                renderParent.element.componentRendererType.encapsulation ===\n                    exports.ViewEncapsulation.Native)) {\n            // only children of non components, or children of components with native encapsulation should\n            // be attached.\n            return asElementData(view, def.renderParent.nodeIndex).renderElement;\n        }\n    }\n    else {\n        return renderHost;\n    }\n}\nvar DEFINITION_CACHE = new WeakMap();\nfunction resolveDefinition(factory) {\n    var value = DEFINITION_CACHE.get(factory);\n    if (!value) {\n        value = factory(function () { return NOOP; });\n        value.factory = factory;\n        DEFINITION_CACHE.set(factory, value);\n    }\n    return value;\n}\nfunction rootRenderNodes(view) {\n    var renderNodes = [];\n    visitRootRenderNodes(view, 0 /* Collect */, undefined, undefined, renderNodes);\n    return renderNodes;\n}\nfunction visitRootRenderNodes(view, action, parentNode, nextSibling, target) {\n    // We need to re-compute the parent node in case the nodes have been moved around manually\n    if (action === 3 /* RemoveChild */) {\n        parentNode = view.renderer.parentNode(renderNode(view, (view.def.lastRenderRootNode)));\n    }\n    visitSiblingRenderNodes(view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);\n}\nfunction visitSiblingRenderNodes(view, action, startIndex, endIndex, parentNode, nextSibling, target) {\n    for (var i = startIndex; i <= endIndex; i++) {\n        var nodeDef = view.def.nodes[i];\n        if (nodeDef.flags & (1 /* TypeElement */ | 2 /* TypeText */ | 8 /* TypeNgContent */)) {\n            visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target);\n        }\n        // jump to next sibling\n        i += nodeDef.childCount;\n    }\n}\nfunction visitProjectedRenderNodes(view, ngContentIndex, action, parentNode, nextSibling, target) {\n    var compView = view;\n    while (compView && !isComponentView(compView)) {\n        compView = compView.parent;\n    }\n    var hostView = compView.parent;\n    var hostElDef = viewParentEl((compView));\n    var startIndex = hostElDef.nodeIndex + 1;\n    var endIndex = hostElDef.nodeIndex + hostElDef.childCount;\n    for (var i = startIndex; i <= endIndex; i++) {\n        var nodeDef = hostView.def.nodes[i];\n        if (nodeDef.ngContentIndex === ngContentIndex) {\n            visitRenderNode((hostView), nodeDef, action, parentNode, nextSibling, target);\n        }\n        // jump to next sibling\n        i += nodeDef.childCount;\n    }\n    if (!hostView.parent) {\n        // a root view\n        var projectedNodes = view.root.projectableNodes[ngContentIndex];\n        if (projectedNodes) {\n            for (var i = 0; i < projectedNodes.length; i++) {\n                execRenderNodeAction(view, projectedNodes[i], action, parentNode, nextSibling, target);\n            }\n        }\n    }\n}\nfunction visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target) {\n    if (nodeDef.flags & 8 /* TypeNgContent */) {\n        visitProjectedRenderNodes(view, nodeDef.ngContent.index, action, parentNode, nextSibling, target);\n    }\n    else {\n        var rn = renderNode(view, nodeDef);\n        if (action === 3 /* RemoveChild */ && (nodeDef.flags & 33554432 /* ComponentView */) &&\n            (nodeDef.bindingFlags & 48 /* CatSyntheticProperty */)) {\n            // Note: we might need to do both actions.\n            if (nodeDef.bindingFlags & (16 /* SyntheticProperty */)) {\n                execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n            }\n            if (nodeDef.bindingFlags & (32 /* SyntheticHostProperty */)) {\n                var compView = asElementData(view, nodeDef.nodeIndex).componentView;\n                execRenderNodeAction(compView, rn, action, parentNode, nextSibling, target);\n            }\n        }\n        else {\n            execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n        }\n        if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n            var embeddedViews = asElementData(view, nodeDef.nodeIndex).viewContainer._embeddedViews;\n            for (var k = 0; k < embeddedViews.length; k++) {\n                visitRootRenderNodes(embeddedViews[k], action, parentNode, nextSibling, target);\n            }\n        }\n        if (nodeDef.flags & 1 /* TypeElement */ && !nodeDef.element.name) {\n            visitSiblingRenderNodes(view, action, nodeDef.nodeIndex + 1, nodeDef.nodeIndex + nodeDef.childCount, parentNode, nextSibling, target);\n        }\n    }\n}\nfunction execRenderNodeAction(view, renderNode, action, parentNode, nextSibling, target) {\n    var renderer = view.renderer;\n    switch (action) {\n        case 1 /* AppendChild */:\n            renderer.appendChild(parentNode, renderNode);\n            break;\n        case 2 /* InsertBefore */:\n            renderer.insertBefore(parentNode, renderNode, nextSibling);\n            break;\n        case 3 /* RemoveChild */:\n            renderer.removeChild(parentNode, renderNode);\n            break;\n        case 0 /* Collect */:\n            target.push(renderNode);\n            break;\n    }\n}\nvar NS_PREFIX_RE = /^:([^:]+):(.+)$/;\nfunction splitNamespace(name) {\n    if (name[0] === ':') {\n        var match = (name.match(NS_PREFIX_RE));\n        return [match[1], match[2]];\n    }\n    return ['', name];\n}\nfunction calcBindingFlags(bindings) {\n    var flags = 0;\n    for (var i = 0; i < bindings.length; i++) {\n        flags |= bindings[i].flags;\n    }\n    return flags;\n}\nfunction interpolate(valueCount, constAndInterp) {\n    var result = '';\n    for (var 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}\nfunction inlineInterpolate(valueCount, c0, a1, c1, a2, c2, a3, c3, a4, c4, a5, c5, a6, c6, a7, c7, a8, c8, a9, c9) {\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}\nfunction _toStringWithNull(v) {\n    return v != null ? v.toString() : '';\n}\nvar EMPTY_ARRAY$2 = [];\nvar EMPTY_MAP = {};\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction anchorDef(flags, matchedQueriesDsl, ngContentIndex, childCount, handleEvent, templateFactory) {\n    flags |= 1 /* TypeElement */;\n    var _a = splitMatchedQueriesDsl(matchedQueriesDsl), matchedQueries = _a.matchedQueries, references = _a.references, matchedQueryIds = _a.matchedQueryIds;\n    var template = templateFactory ? resolveDefinition(templateFactory) : null;\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        flags: flags,\n        checkIndex: -1,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0, matchedQueries: matchedQueries, matchedQueryIds: matchedQueryIds, references: references, ngContentIndex: ngContentIndex, childCount: childCount,\n        bindings: [],\n        bindingFlags: 0,\n        outputs: [],\n        element: {\n            ns: null,\n            name: null,\n            attrs: null, template: 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}\nfunction elementDef(checkIndex, flags, matchedQueriesDsl, ngContentIndex, childCount, namespaceAndName, fixedAttrs, bindings, outputs, handleEvent, componentView, componentRendererType) {\n    if (fixedAttrs === void 0) { fixedAttrs = []; }\n    if (!handleEvent) {\n        handleEvent = NOOP;\n    }\n    var _a = splitMatchedQueriesDsl(matchedQueriesDsl), matchedQueries = _a.matchedQueries, references = _a.references, matchedQueryIds = _a.matchedQueryIds;\n    var ns = (null);\n    var name = (null);\n    if (namespaceAndName) {\n        _b = __read(splitNamespace(namespaceAndName), 2), ns = _b[0], name = _b[1];\n    }\n    bindings = bindings || [];\n    var bindingDefs = new Array(bindings.length);\n    for (var i = 0; i < bindings.length; i++) {\n        var _c = __read(bindings[i], 3), bindingFlags = _c[0], namespaceAndName_1 = _c[1], suffixOrSecurityContext = _c[2];\n        var _d = __read(splitNamespace(namespaceAndName_1), 2), ns_1 = _d[0], name_1 = _d[1];\n        var securityContext = (undefined);\n        var suffix = (undefined);\n        switch (bindingFlags & 15 /* Types */) {\n            case 4 /* TypeElementStyle */:\n                suffix = suffixOrSecurityContext;\n                break;\n            case 1 /* TypeElementAttribute */:\n            case 8 /* TypeProperty */:\n                securityContext = suffixOrSecurityContext;\n                break;\n        }\n        bindingDefs[i] =\n            { flags: bindingFlags, ns: ns_1, name: name_1, nonMinifiedName: name_1, securityContext: securityContext, suffix: suffix };\n    }\n    outputs = outputs || [];\n    var outputDefs = new Array(outputs.length);\n    for (var i = 0; i < outputs.length; i++) {\n        var _e = __read(outputs[i], 2), target = _e[0], eventName = _e[1];\n        outputDefs[i] = {\n            type: 0 /* ElementOutput */,\n            target: target, eventName: eventName,\n            propName: null\n        };\n    }\n    fixedAttrs = fixedAttrs || [];\n    var attrs = fixedAttrs.map(function (_a) {\n        var _b = __read(_a, 2), namespaceAndName = _b[0], value = _b[1];\n        var _c = __read(splitNamespace(namespaceAndName), 2), ns = _c[0], name = _c[1];\n        return [ns, name, value];\n    });\n    componentRendererType = resolveRendererType2(componentRendererType);\n    if (componentView) {\n        flags |= 33554432 /* ComponentView */;\n    }\n    flags |= 1 /* TypeElement */;\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: flags,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0, matchedQueries: matchedQueries, matchedQueryIds: matchedQueryIds, references: references, ngContentIndex: ngContentIndex, childCount: childCount,\n        bindings: bindingDefs,\n        bindingFlags: calcBindingFlags(bindingDefs),\n        outputs: outputDefs,\n        element: {\n            ns: ns,\n            name: name,\n            attrs: 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    var _b;\n}\nfunction createElement(view, renderHost, def) {\n    var elDef = (def.element);\n    var rootSelectorOrNode = view.root.selectorOrNode;\n    var renderer = view.renderer;\n    var el;\n    if (view.parent || !rootSelectorOrNode) {\n        if (elDef.name) {\n            el = renderer.createElement(elDef.name, elDef.ns);\n        }\n        else {\n            el = renderer.createComment('');\n        }\n        var parentEl = getParentRenderElement(view, renderHost, def);\n        if (parentEl) {\n            renderer.appendChild(parentEl, el);\n        }\n    }\n    else {\n        el = renderer.selectRootElement(rootSelectorOrNode);\n    }\n    if (elDef.attrs) {\n        for (var i = 0; i < elDef.attrs.length; i++) {\n            var _a = __read(elDef.attrs[i], 3), ns = _a[0], name_2 = _a[1], value = _a[2];\n            renderer.setAttribute(el, name_2, value, ns);\n        }\n    }\n    return el;\n}\nfunction listenToElementOutputs(view, compView, def, el) {\n    for (var i = 0; i < def.outputs.length; i++) {\n        var output = def.outputs[i];\n        var handleEventClosure = renderEventHandlerClosure(view, def.nodeIndex, elementEventFullName(output.target, output.eventName));\n        var listenTarget = output.target;\n        var listenerView = view;\n        if (output.target === 'component') {\n            listenTarget = null;\n            listenerView = compView;\n        }\n        var disposable = listenerView.renderer.listen(listenTarget || el, output.eventName, handleEventClosure);\n        view.disposables[def.outputIndex + i] = disposable;\n    }\n}\nfunction renderEventHandlerClosure(view, index, eventName) {\n    return function (event) { return dispatchEvent(view, index, eventName, event); };\n}\nfunction checkAndUpdateElementInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var bindLen = def.bindings.length;\n    var changed = false;\n    if (bindLen > 0 && checkAndUpdateElementValue(view, def, 0, v0))\n        changed = true;\n    if (bindLen > 1 && checkAndUpdateElementValue(view, def, 1, v1))\n        changed = true;\n    if (bindLen > 2 && checkAndUpdateElementValue(view, def, 2, v2))\n        changed = true;\n    if (bindLen > 3 && checkAndUpdateElementValue(view, def, 3, v3))\n        changed = true;\n    if (bindLen > 4 && checkAndUpdateElementValue(view, def, 4, v4))\n        changed = true;\n    if (bindLen > 5 && checkAndUpdateElementValue(view, def, 5, v5))\n        changed = true;\n    if (bindLen > 6 && checkAndUpdateElementValue(view, def, 6, v6))\n        changed = true;\n    if (bindLen > 7 && checkAndUpdateElementValue(view, def, 7, v7))\n        changed = true;\n    if (bindLen > 8 && checkAndUpdateElementValue(view, def, 8, v8))\n        changed = true;\n    if (bindLen > 9 && checkAndUpdateElementValue(view, def, 9, v9))\n        changed = true;\n    return changed;\n}\nfunction checkAndUpdateElementDynamic(view, def, values) {\n    var changed = false;\n    for (var i = 0; i < values.length; i++) {\n        if (checkAndUpdateElementValue(view, def, i, values[i]))\n            changed = true;\n    }\n    return changed;\n}\nfunction checkAndUpdateElementValue(view, def, bindingIdx, value) {\n    if (!checkAndUpdateBinding(view, def, bindingIdx, value)) {\n        return false;\n    }\n    var binding = def.bindings[bindingIdx];\n    var elData = asElementData(view, def.nodeIndex);\n    var renderNode$$1 = elData.renderElement;\n    var name = (binding.name);\n    switch (binding.flags & 15 /* Types */) {\n        case 1 /* TypeElementAttribute */:\n            setElementAttribute(view, binding, renderNode$$1, binding.ns, name, value);\n            break;\n        case 2 /* TypeElementClass */:\n            setElementClass(view, renderNode$$1, name, value);\n            break;\n        case 4 /* TypeElementStyle */:\n            setElementStyle(view, binding, renderNode$$1, name, value);\n            break;\n        case 8 /* TypeProperty */:\n            var bindView = (def.flags & 33554432 /* ComponentView */ &&\n                binding.flags & 32 /* SyntheticHostProperty */) ?\n                elData.componentView :\n                view;\n            setElementProperty(bindView, binding, renderNode$$1, name, value);\n            break;\n    }\n    return true;\n}\nfunction setElementAttribute(view, binding, renderNode$$1, ns, name, value) {\n    var securityContext = binding.securityContext;\n    var renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;\n    renderValue = renderValue != null ? renderValue.toString() : null;\n    var renderer = view.renderer;\n    if (value != null) {\n        renderer.setAttribute(renderNode$$1, name, renderValue, ns);\n    }\n    else {\n        renderer.removeAttribute(renderNode$$1, name, ns);\n    }\n}\nfunction setElementClass(view, renderNode$$1, name, value) {\n    var renderer = view.renderer;\n    if (value) {\n        renderer.addClass(renderNode$$1, name);\n    }\n    else {\n        renderer.removeClass(renderNode$$1, name);\n    }\n}\nfunction setElementStyle(view, binding, renderNode$$1, name, value) {\n    var renderValue = view.root.sanitizer.sanitize(exports.SecurityContext.STYLE, value);\n    if (renderValue != null) {\n        renderValue = renderValue.toString();\n        var unit = binding.suffix;\n        if (unit != null) {\n            renderValue = renderValue + unit;\n        }\n    }\n    else {\n        renderValue = null;\n    }\n    var renderer = view.renderer;\n    if (renderValue != null) {\n        renderer.setStyle(renderNode$$1, name, renderValue);\n    }\n    else {\n        renderer.removeStyle(renderNode$$1, name);\n    }\n}\nfunction setElementProperty(view, binding, renderNode$$1, name, value) {\n    var securityContext = binding.securityContext;\n    var renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;\n    view.renderer.setProperty(renderNode$$1, name, renderValue);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar UNDEFINED_VALUE = new Object();\nvar InjectorRefTokenKey$1 = tokenKey(Injector);\nvar INJECTORRefTokenKey$1 = tokenKey(INJECTOR);\nvar NgModuleRefTokenKey = tokenKey(NgModuleRef);\nfunction moduleProvideDef(flags, token, value, deps) {\n    // Need to resolve forwardRefs as e.g. for `useValue` we\n    // lowered the expression and then stopped evaluating it,\n    // i.e. also didn't unwrap it.\n    value = resolveForwardRef(value);\n    var depDefs = splitDepsDsl(deps, stringify(token));\n    return {\n        // will bet set by the module definition\n        index: -1,\n        deps: depDefs, flags: flags, token: token, value: value\n    };\n}\nfunction moduleDef(providers) {\n    var providersByKey = {};\n    var modules = [];\n    var isRoot = false;\n    for (var i = 0; i < providers.length; i++) {\n        var provider = providers[i];\n        if (provider.token === APP_ROOT) {\n            isRoot = true;\n        }\n        if (provider.flags & 1073741824 /* TypeNgModule */) {\n            modules.push(provider.token);\n        }\n        provider.index = i;\n        providersByKey[tokenKey(provider.token)] = provider;\n    }\n    return {\n        // Will be filled later...\n        factory: null,\n        providersByKey: providersByKey,\n        providers: providers,\n        modules: modules,\n        isRoot: isRoot,\n    };\n}\nfunction initNgModule(data) {\n    var def = data._def;\n    var providers = data._providers = new Array(def.providers.length);\n    for (var i = 0; i < def.providers.length; i++) {\n        var provDef = def.providers[i];\n        if (!(provDef.flags & 4096 /* LazyProvider */)) {\n            // Make sure the provider has not been already initialized outside this loop.\n            if (providers[i] === undefined) {\n                providers[i] = _createProviderInstance$1(data, provDef);\n            }\n        }\n    }\n}\nfunction resolveNgModuleDep(data, depDef, notFoundValue) {\n    if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n    var former = setCurrentInjector(data);\n    try {\n        if (depDef.flags & 8 /* Value */) {\n            return depDef.token;\n        }\n        if (depDef.flags & 2 /* Optional */) {\n            notFoundValue = null;\n        }\n        if (depDef.flags & 1 /* SkipSelf */) {\n            return data._parent.get(depDef.token, notFoundValue);\n        }\n        var tokenKey_1 = depDef.tokenKey;\n        switch (tokenKey_1) {\n            case InjectorRefTokenKey$1:\n            case INJECTORRefTokenKey$1:\n            case NgModuleRefTokenKey:\n                return data;\n        }\n        var providerDef = data._def.providersByKey[tokenKey_1];\n        if (providerDef) {\n            var providerInstance = data._providers[providerDef.index];\n            if (providerInstance === undefined) {\n                providerInstance = data._providers[providerDef.index] =\n                    _createProviderInstance$1(data, providerDef);\n            }\n            return providerInstance === UNDEFINED_VALUE ? undefined : providerInstance;\n        }\n        else if (depDef.token.ngInjectableDef && targetsModule(data, depDef.token.ngInjectableDef)) {\n            var injectableDef = depDef.token.ngInjectableDef;\n            var index = data._providers.length;\n            data._def.providersByKey[depDef.tokenKey] = {\n                flags: 1024 /* TypeFactoryProvider */ | 4096 /* LazyProvider */,\n                value: injectableDef.factory,\n                deps: [], index: index,\n                token: depDef.token,\n            };\n            data._providers[index] = UNDEFINED_VALUE;\n            return (data._providers[index] =\n                _createProviderInstance$1(data, data._def.providersByKey[depDef.tokenKey]));\n        }\n        return data._parent.get(depDef.token, notFoundValue);\n    }\n    finally {\n        setCurrentInjector(former);\n    }\n}\nfunction moduleTransitivelyPresent(ngModule, scope) {\n    return ngModule._def.modules.indexOf(scope) > -1;\n}\nfunction targetsModule(ngModule, def) {\n    return def.providedIn != null && (moduleTransitivelyPresent(ngModule, def.providedIn) ||\n        def.providedIn === 'root' && ngModule._def.isRoot);\n}\nfunction _createProviderInstance$1(ngModule, providerDef) {\n    var injectable;\n    switch (providerDef.flags & 201347067 /* Types */) {\n        case 512 /* TypeClassProvider */:\n            injectable = _createClass(ngModule, providerDef.value, providerDef.deps);\n            break;\n        case 1024 /* TypeFactoryProvider */:\n            injectable = _callFactory(ngModule, providerDef.value, providerDef.deps);\n            break;\n        case 2048 /* TypeUseExistingProvider */:\n            injectable = resolveNgModuleDep(ngModule, providerDef.deps[0]);\n            break;\n        case 256 /* TypeValueProvider */:\n            injectable = providerDef.value;\n            break;\n    }\n    // The read of `ngOnDestroy` here is slightly expensive as it's megamorphic, so it should be\n    // avoided if possible. The sequence of checks here determines whether ngOnDestroy needs to be\n    // checked. It might not if the `injectable` isn't an object or if NodeFlags.OnDestroy is already\n    // set (ngOnDestroy was detected statically).\n    if (injectable !== UNDEFINED_VALUE && injectable != null && typeof injectable === 'object' &&\n        !(providerDef.flags & 131072 /* OnDestroy */) && typeof injectable.ngOnDestroy === 'function') {\n        providerDef.flags |= 131072 /* OnDestroy */;\n    }\n    return injectable === undefined ? UNDEFINED_VALUE : injectable;\n}\nfunction _createClass(ngModule, ctor, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return new ctor();\n        case 1:\n            return new ctor(resolveNgModuleDep(ngModule, deps[0]));\n        case 2:\n            return new ctor(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));\n        case 3:\n            return new ctor(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]), resolveNgModuleDep(ngModule, deps[2]));\n        default:\n            var depValues = new Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveNgModuleDep(ngModule, deps[i]);\n            }\n            return new (ctor.bind.apply(ctor, __spread([void 0], depValues)))();\n    }\n}\nfunction _callFactory(ngModule, factory, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return factory();\n        case 1:\n            return factory(resolveNgModuleDep(ngModule, deps[0]));\n        case 2:\n            return factory(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));\n        case 3:\n            return factory(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]), resolveNgModuleDep(ngModule, deps[2]));\n        default:\n            var depValues = Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveNgModuleDep(ngModule, deps[i]);\n            }\n            return factory.apply(void 0, __spread(depValues));\n    }\n}\nfunction callNgModuleLifecycle(ngModule, lifecycles) {\n    var def = ngModule._def;\n    var destroyed = new Set();\n    for (var i = 0; i < def.providers.length; i++) {\n        var provDef = def.providers[i];\n        if (provDef.flags & 131072 /* OnDestroy */) {\n            var instance = ngModule._providers[i];\n            if (instance && instance !== UNDEFINED_VALUE) {\n                var onDestroy = instance.ngOnDestroy;\n                if (typeof onDestroy === 'function' && !destroyed.has(instance)) {\n                    onDestroy.apply(instance);\n                    destroyed.add(instance);\n                }\n            }\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 */\nfunction attachEmbeddedView(parentView, elementData, viewIndex, view) {\n    var embeddedViews = elementData.viewContainer._embeddedViews;\n    if (viewIndex === null || viewIndex === undefined) {\n        viewIndex = embeddedViews.length;\n    }\n    view.viewContainerParent = parentView;\n    addToArray(embeddedViews, (viewIndex), view);\n    attachProjectedView(elementData, view);\n    Services.dirtyParentQueries(view);\n    var prevView = (viewIndex) > 0 ? embeddedViews[(viewIndex) - 1] : null;\n    renderAttachEmbeddedView(elementData, prevView, view);\n}\nfunction attachProjectedView(vcElementData, view) {\n    var dvcElementData = declaredViewContainer(view);\n    if (!dvcElementData || dvcElementData === vcElementData ||\n        view.state & 16 /* 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 across 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 |= 16 /* IsProjectedView */;\n    var 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(view.parent.def, (view.parentNodeDef));\n}\nfunction markNodeAsProjectedTemplate(viewDef, nodeDef) {\n    if (nodeDef.flags & 4 /* ProjectedTemplate */) {\n        return;\n    }\n    viewDef.nodeFlags |= 4 /* ProjectedTemplate */;\n    nodeDef.flags |= 4 /* ProjectedTemplate */;\n    var parentNodeDef = nodeDef.parent;\n    while (parentNodeDef) {\n        parentNodeDef.childFlags |= 4 /* ProjectedTemplate */;\n        parentNodeDef = parentNodeDef.parent;\n    }\n}\nfunction detachEmbeddedView(elementData, viewIndex) {\n    var embeddedViews = 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    var view = embeddedViews[viewIndex];\n    view.viewContainerParent = null;\n    removeFromArray(embeddedViews, viewIndex);\n    // See attachProjectedView for why we don't update projectedViews here.\n    Services.dirtyParentQueries(view);\n    renderDetachView(view);\n    return view;\n}\nfunction detachProjectedView(view) {\n    if (!(view.state & 16 /* IsProjectedView */)) {\n        return;\n    }\n    var dvcElementData = declaredViewContainer(view);\n    if (dvcElementData) {\n        var projectedViews = dvcElementData.template._projectedViews;\n        if (projectedViews) {\n            removeFromArray(projectedViews, projectedViews.indexOf(view));\n            Services.dirtyParentQueries(view);\n        }\n    }\n}\nfunction moveEmbeddedView(elementData, oldViewIndex, newViewIndex) {\n    var embeddedViews = elementData.viewContainer._embeddedViews;\n    var view = embeddedViews[oldViewIndex];\n    removeFromArray(embeddedViews, oldViewIndex);\n    if (newViewIndex == null) {\n        newViewIndex = embeddedViews.length;\n    }\n    addToArray(embeddedViews, newViewIndex, view);\n    // Note: Don't need to change projectedViews as the order in there\n    // as always invalid...\n    Services.dirtyParentQueries(view);\n    renderDetachView(view);\n    var prevView = newViewIndex > 0 ? embeddedViews[newViewIndex - 1] : null;\n    renderAttachEmbeddedView(elementData, prevView, view);\n    return view;\n}\nfunction renderAttachEmbeddedView(elementData, prevView, view) {\n    var prevRenderNode = prevView ? renderNode(prevView, (prevView.def.lastRenderRootNode)) :\n        elementData.renderElement;\n    var parentNode = view.renderer.parentNode(prevRenderNode);\n    var 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, 2 /* InsertBefore */, parentNode, nextSibling, undefined);\n}\nfunction renderDetachView(view) {\n    visitRootRenderNodes(view, 3 /* RemoveChild */, null, null, undefined);\n}\nfunction addToArray(arr, index, value) {\n    // perf: array.push is faster than array.splice!\n    if (index >= arr.length) {\n        arr.push(value);\n    }\n    else {\n        arr.splice(index, 0, value);\n    }\n}\nfunction removeFromArray(arr, index) {\n    // perf: array.pop is faster than array.splice!\n    if (index >= arr.length - 1) {\n        arr.pop();\n    }\n    else {\n        arr.splice(index, 1);\n    }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar EMPTY_CONTEXT = new Object();\n// Attention: this function is called as top level function.\n// Putting any logic in here will destroy closure tree shaking!\nfunction createComponentFactory(selector, componentType, viewDefFactory, inputs, outputs, ngContentSelectors) {\n    return new ComponentFactory_(selector, componentType, viewDefFactory, inputs, outputs, ngContentSelectors);\n}\nfunction getComponentViewDefinitionFactory(componentFactory) {\n    return componentFactory.viewDefFactory;\n}\nvar ComponentFactory_ = /** @class */ (function (_super) {\n    __extends(ComponentFactory_, _super);\n    function ComponentFactory_(selector, componentType, viewDefFactory, _inputs, _outputs, ngContentSelectors) {\n        var _this = \n        // Attention: this ctor is called as top level function.\n        // Putting any logic in here will destroy closure tree shaking!\n        _super.call(this) || this;\n        _this.selector = selector;\n        _this.componentType = componentType;\n        _this._inputs = _inputs;\n        _this._outputs = _outputs;\n        _this.ngContentSelectors = ngContentSelectors;\n        _this.viewDefFactory = viewDefFactory;\n        return _this;\n    }\n    Object.defineProperty(ComponentFactory_.prototype, \"inputs\", {\n        get: function () {\n            var inputsArr = [];\n            var inputs = (this._inputs);\n            for (var propName in inputs) {\n                var templateName = inputs[propName];\n                inputsArr.push({ propName: propName, templateName: templateName });\n            }\n            return inputsArr;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ComponentFactory_.prototype, \"outputs\", {\n        get: function () {\n            var outputsArr = [];\n            for (var propName in this._outputs) {\n                var templateName = this._outputs[propName];\n                outputsArr.push({ propName: propName, templateName: templateName });\n            }\n            return outputsArr;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Creates a new component.\n     */\n    /**\n       * Creates a new component.\n       */\n    ComponentFactory_.prototype.create = /**\n       * Creates a new component.\n       */\n    function (injector, projectableNodes, rootSelectorOrNode, ngModule) {\n        if (!ngModule) {\n            throw new Error('ngModule should be provided');\n        }\n        var viewDef = resolveDefinition(this.viewDefFactory);\n        var componentNodeIndex = viewDef.nodes[0].element.componentProvider.nodeIndex;\n        var view = Services.createRootView(injector, projectableNodes || [], rootSelectorOrNode, viewDef, ngModule, EMPTY_CONTEXT);\n        var component = asProviderData(view, componentNodeIndex).instance;\n        if (rootSelectorOrNode) {\n            view.renderer.setAttribute(asElementData(view, 0).renderElement, 'ng-version', VERSION.full);\n        }\n        return new ComponentRef_(view, new ViewRef_(view), component);\n    };\n    return ComponentFactory_;\n}(ComponentFactory));\nvar ComponentRef_ = /** @class */ (function (_super) {\n    __extends(ComponentRef_, _super);\n    function ComponentRef_(_view, _viewRef, _component) {\n        var _this = _super.call(this) || this;\n        _this._view = _view;\n        _this._viewRef = _viewRef;\n        _this._component = _component;\n        _this._elDef = _this._view.def.nodes[0];\n        _this.hostView = _viewRef;\n        _this.changeDetectorRef = _viewRef;\n        _this.instance = _component;\n        return _this;\n    }\n    Object.defineProperty(ComponentRef_.prototype, \"location\", {\n        get: function () {\n            return new ElementRef(asElementData(this._view, this._elDef.nodeIndex).renderElement);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ComponentRef_.prototype, \"injector\", {\n        get: function () { return new Injector_(this._view, this._elDef); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ComponentRef_.prototype, \"componentType\", {\n        get: function () { return this._component.constructor; },\n        enumerable: true,\n        configurable: true\n    });\n    ComponentRef_.prototype.destroy = function () { this._viewRef.destroy(); };\n    ComponentRef_.prototype.onDestroy = function (callback) { this._viewRef.onDestroy(callback); };\n    return ComponentRef_;\n}(ComponentRef));\nfunction createViewContainerData(view, elDef, elData) {\n    return new ViewContainerRef_(view, elDef, elData);\n}\nvar ViewContainerRef_ = /** @class */ (function () {\n    function ViewContainerRef_(_view, _elDef, _data) {\n        this._view = _view;\n        this._elDef = _elDef;\n        this._data = _data;\n        /**\n           * @internal\n           */\n        this._embeddedViews = [];\n    }\n    Object.defineProperty(ViewContainerRef_.prototype, \"element\", {\n        get: function () { return new ElementRef(this._data.renderElement); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewContainerRef_.prototype, \"injector\", {\n        get: function () { return new Injector_(this._view, this._elDef); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewContainerRef_.prototype, \"parentInjector\", {\n        get: function () {\n            var view = this._view;\n            var elDef = this._elDef.parent;\n            while (!elDef && view) {\n                elDef = viewParentEl(view);\n                view = (view.parent);\n            }\n            return view ? new Injector_(view, elDef) : new Injector_(this._view, null);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ViewContainerRef_.prototype.clear = function () {\n        var len = this._embeddedViews.length;\n        for (var i = len - 1; i >= 0; i--) {\n            var view = (detachEmbeddedView(this._data, i));\n            Services.destroyView(view);\n        }\n    };\n    ViewContainerRef_.prototype.get = function (index) {\n        var view = this._embeddedViews[index];\n        if (view) {\n            var ref = new ViewRef_(view);\n            ref.attachToViewContainerRef(this);\n            return ref;\n        }\n        return null;\n    };\n    Object.defineProperty(ViewContainerRef_.prototype, \"length\", {\n        get: function () { return this._embeddedViews.length; },\n        enumerable: true,\n        configurable: true\n    });\n    ViewContainerRef_.prototype.createEmbeddedView = function (templateRef, context, index) {\n        var viewRef = templateRef.createEmbeddedView(context || {});\n        this.insert(viewRef, index);\n        return viewRef;\n    };\n    ViewContainerRef_.prototype.createComponent = function (componentFactory, index, injector, projectableNodes, ngModuleRef) {\n        var contextInjector = injector || this.parentInjector;\n        if (!ngModuleRef && !(componentFactory instanceof ComponentFactoryBoundToModule)) {\n            ngModuleRef = contextInjector.get(NgModuleRef);\n        }\n        var componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);\n        this.insert(componentRef.hostView, index);\n        return componentRef;\n    };\n    ViewContainerRef_.prototype.insert = function (viewRef, index) {\n        if (viewRef.destroyed) {\n            throw new Error('Cannot insert a destroyed View in a ViewContainer!');\n        }\n        var viewRef_ = viewRef;\n        var viewData = viewRef_._view;\n        attachEmbeddedView(this._view, this._data, index, viewData);\n        viewRef_.attachToViewContainerRef(this);\n        return viewRef;\n    };\n    ViewContainerRef_.prototype.move = function (viewRef, currentIndex) {\n        if (viewRef.destroyed) {\n            throw new Error('Cannot move a destroyed View in a ViewContainer!');\n        }\n        var previousIndex = this._embeddedViews.indexOf(viewRef._view);\n        moveEmbeddedView(this._data, previousIndex, currentIndex);\n        return viewRef;\n    };\n    ViewContainerRef_.prototype.indexOf = function (viewRef) {\n        return this._embeddedViews.indexOf(viewRef._view);\n    };\n    ViewContainerRef_.prototype.remove = function (index) {\n        var viewData = detachEmbeddedView(this._data, index);\n        if (viewData) {\n            Services.destroyView(viewData);\n        }\n    };\n    ViewContainerRef_.prototype.detach = function (index) {\n        var view = detachEmbeddedView(this._data, index);\n        return view ? new ViewRef_(view) : null;\n    };\n    return ViewContainerRef_;\n}());\nfunction createChangeDetectorRef(view) {\n    return new ViewRef_(view);\n}\nvar ViewRef_ = /** @class */ (function () {\n    function ViewRef_(_view) {\n        this._view = _view;\n        this._viewContainerRef = null;\n        this._appRef = null;\n    }\n    Object.defineProperty(ViewRef_.prototype, \"rootNodes\", {\n        get: function () { return rootRenderNodes(this._view); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewRef_.prototype, \"context\", {\n        get: function () { return this._view.context; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewRef_.prototype, \"destroyed\", {\n        get: function () { return (this._view.state & 128 /* Destroyed */) !== 0; },\n        enumerable: true,\n        configurable: true\n    });\n    ViewRef_.prototype.markForCheck = function () { markParentViewsForCheck(this._view); };\n    ViewRef_.prototype.detach = function () { this._view.state &= ~4 /* Attached */; };\n    ViewRef_.prototype.detectChanges = function () {\n        var fs = this._view.root.rendererFactory;\n        if (fs.begin) {\n            fs.begin();\n        }\n        try {\n            Services.checkAndUpdateView(this._view);\n        }\n        finally {\n            if (fs.end) {\n                fs.end();\n            }\n        }\n    };\n    ViewRef_.prototype.checkNoChanges = function () { Services.checkNoChangesView(this._view); };\n    ViewRef_.prototype.reattach = function () { this._view.state |= 4 /* Attached */; };\n    ViewRef_.prototype.onDestroy = function (callback) {\n        if (!this._view.disposables) {\n            this._view.disposables = [];\n        }\n        this._view.disposables.push(callback);\n    };\n    ViewRef_.prototype.destroy = function () {\n        if (this._appRef) {\n            this._appRef.detachView(this);\n        }\n        else if (this._viewContainerRef) {\n            this._viewContainerRef.detach(this._viewContainerRef.indexOf(this));\n        }\n        Services.destroyView(this._view);\n    };\n    ViewRef_.prototype.detachFromAppRef = function () {\n        this._appRef = null;\n        renderDetachView(this._view);\n        Services.dirtyParentQueries(this._view);\n    };\n    ViewRef_.prototype.attachToAppRef = function (appRef) {\n        if (this._viewContainerRef) {\n            throw new Error('This view is already attached to a ViewContainer!');\n        }\n        this._appRef = appRef;\n    };\n    ViewRef_.prototype.attachToViewContainerRef = function (vcRef) {\n        if (this._appRef) {\n            throw new Error('This view is already attached directly to the ApplicationRef!');\n        }\n        this._viewContainerRef = vcRef;\n    };\n    return ViewRef_;\n}());\nfunction createTemplateData(view, def) {\n    return new TemplateRef_(view, def);\n}\nvar TemplateRef_ = /** @class */ (function (_super) {\n    __extends(TemplateRef_, _super);\n    function TemplateRef_(_parentView, _def) {\n        var _this = _super.call(this) || this;\n        _this._parentView = _parentView;\n        _this._def = _def;\n        return _this;\n    }\n    TemplateRef_.prototype.createEmbeddedView = function (context) {\n        return new ViewRef_(Services.createEmbeddedView(this._parentView, this._def, (this._def.element.template), context));\n    };\n    Object.defineProperty(TemplateRef_.prototype, \"elementRef\", {\n        get: function () {\n            return new ElementRef(asElementData(this._parentView, this._def.nodeIndex).renderElement);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return TemplateRef_;\n}(TemplateRef));\nfunction createInjector$1(view, elDef) {\n    return new Injector_(view, elDef);\n}\nvar Injector_ = /** @class */ (function () {\n    function Injector_(view, elDef) {\n        this.view = view;\n        this.elDef = elDef;\n    }\n    Injector_.prototype.get = function (token, notFoundValue) {\n        if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n        var allowPrivateServices = this.elDef ? (this.elDef.flags & 33554432 /* ComponentView */) !== 0 : false;\n        return Services.resolveDep(this.view, this.elDef, allowPrivateServices, { flags: 0 /* None */, token: token, tokenKey: tokenKey(token) }, notFoundValue);\n    };\n    return Injector_;\n}());\nfunction nodeValue(view, index) {\n    var def = view.def.nodes[index];\n    if (def.flags & 1 /* TypeElement */) {\n        var elData = asElementData(view, def.nodeIndex);\n        return def.element.template ? elData.template : elData.renderElement;\n    }\n    else if (def.flags & 2 /* TypeText */) {\n        return asTextData(view, def.nodeIndex).renderText;\n    }\n    else if (def.flags & (20224 /* CatProvider */ | 16 /* TypePipe */)) {\n        return asProviderData(view, def.nodeIndex).instance;\n    }\n    throw new Error(\"Illegal state: read nodeValue for node index \" + index);\n}\nfunction createRendererV1(view) {\n    return new RendererAdapter(view.renderer);\n}\nvar RendererAdapter = /** @class */ (function () {\n    function RendererAdapter(delegate) {\n        this.delegate = delegate;\n    }\n    RendererAdapter.prototype.selectRootElement = function (selectorOrNode) {\n        return this.delegate.selectRootElement(selectorOrNode);\n    };\n    RendererAdapter.prototype.createElement = function (parent, namespaceAndName) {\n        var _a = __read(splitNamespace(namespaceAndName), 2), ns = _a[0], name = _a[1];\n        var el = this.delegate.createElement(name, ns);\n        if (parent) {\n            this.delegate.appendChild(parent, el);\n        }\n        return el;\n    };\n    RendererAdapter.prototype.createViewRoot = function (hostElement) { return hostElement; };\n    RendererAdapter.prototype.createTemplateAnchor = function (parentElement) {\n        var comment = this.delegate.createComment('');\n        if (parentElement) {\n            this.delegate.appendChild(parentElement, comment);\n        }\n        return comment;\n    };\n    RendererAdapter.prototype.createText = function (parentElement, value) {\n        var node = this.delegate.createText(value);\n        if (parentElement) {\n            this.delegate.appendChild(parentElement, node);\n        }\n        return node;\n    };\n    RendererAdapter.prototype.projectNodes = function (parentElement, nodes) {\n        for (var i = 0; i < nodes.length; i++) {\n            this.delegate.appendChild(parentElement, nodes[i]);\n        }\n    };\n    RendererAdapter.prototype.attachViewAfter = function (node, viewRootNodes) {\n        var parentElement = this.delegate.parentNode(node);\n        var nextSibling = this.delegate.nextSibling(node);\n        for (var i = 0; i < viewRootNodes.length; i++) {\n            this.delegate.insertBefore(parentElement, viewRootNodes[i], nextSibling);\n        }\n    };\n    RendererAdapter.prototype.detachView = function (viewRootNodes) {\n        for (var i = 0; i < viewRootNodes.length; i++) {\n            var node = viewRootNodes[i];\n            var parentElement = this.delegate.parentNode(node);\n            this.delegate.removeChild(parentElement, node);\n        }\n    };\n    RendererAdapter.prototype.destroyView = function (hostElement, viewAllNodes) {\n        for (var i = 0; i < viewAllNodes.length; i++) {\n            this.delegate.destroyNode(viewAllNodes[i]);\n        }\n    };\n    RendererAdapter.prototype.listen = function (renderElement, name, callback) {\n        return this.delegate.listen(renderElement, name, callback);\n    };\n    RendererAdapter.prototype.listenGlobal = function (target, name, callback) {\n        return this.delegate.listen(target, name, callback);\n    };\n    RendererAdapter.prototype.setElementProperty = function (renderElement, propertyName, propertyValue) {\n        this.delegate.setProperty(renderElement, propertyName, propertyValue);\n    };\n    RendererAdapter.prototype.setElementAttribute = function (renderElement, namespaceAndName, attributeValue) {\n        var _a = __read(splitNamespace(namespaceAndName), 2), ns = _a[0], name = _a[1];\n        if (attributeValue != null) {\n            this.delegate.setAttribute(renderElement, name, attributeValue, ns);\n        }\n        else {\n            this.delegate.removeAttribute(renderElement, name, ns);\n        }\n    };\n    RendererAdapter.prototype.setBindingDebugInfo = function (renderElement, propertyName, propertyValue) { };\n    RendererAdapter.prototype.setElementClass = function (renderElement, className, isAdd) {\n        if (isAdd) {\n            this.delegate.addClass(renderElement, className);\n        }\n        else {\n            this.delegate.removeClass(renderElement, className);\n        }\n    };\n    RendererAdapter.prototype.setElementStyle = function (renderElement, styleName, styleValue) {\n        if (styleValue != null) {\n            this.delegate.setStyle(renderElement, styleName, styleValue);\n        }\n        else {\n            this.delegate.removeStyle(renderElement, styleName);\n        }\n    };\n    RendererAdapter.prototype.invokeElementMethod = function (renderElement, methodName, args) {\n        renderElement[methodName].apply(renderElement, args);\n    };\n    RendererAdapter.prototype.setText = function (renderNode$$1, text) { this.delegate.setValue(renderNode$$1, text); };\n    RendererAdapter.prototype.animate = function () { throw new Error('Renderer.animate is no longer supported!'); };\n    return RendererAdapter;\n}());\nfunction createNgModuleRef(moduleType, parent, bootstrapComponents, def) {\n    return new NgModuleRef_(moduleType, parent, bootstrapComponents, def);\n}\nvar NgModuleRef_ = /** @class */ (function () {\n    function NgModuleRef_(_moduleType, _parent, _bootstrapComponents, _def) {\n        this._moduleType = _moduleType;\n        this._parent = _parent;\n        this._bootstrapComponents = _bootstrapComponents;\n        this._def = _def;\n        this._destroyListeners = [];\n        this._destroyed = false;\n        this.injector = this;\n        initNgModule(this);\n    }\n    NgModuleRef_.prototype.get = function (token, notFoundValue, injectFlags) {\n        if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n        if (injectFlags === void 0) { injectFlags = 0 /* Default */; }\n        var flags = 0;\n        if (injectFlags & 4 /* SkipSelf */) {\n            flags |= 1 /* SkipSelf */;\n        }\n        else if (injectFlags & 2 /* Self */) {\n            flags |= 4 /* Self */;\n        }\n        return resolveNgModuleDep(this, { token: token, tokenKey: tokenKey(token), flags: flags }, notFoundValue);\n    };\n    Object.defineProperty(NgModuleRef_.prototype, \"instance\", {\n        get: function () { return this.get(this._moduleType); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NgModuleRef_.prototype, \"componentFactoryResolver\", {\n        get: function () { return this.get(ComponentFactoryResolver); },\n        enumerable: true,\n        configurable: true\n    });\n    NgModuleRef_.prototype.destroy = function () {\n        if (this._destroyed) {\n            throw new Error(\"The ng module \" + stringify(this.instance.constructor) + \" has already been destroyed.\");\n        }\n        this._destroyed = true;\n        callNgModuleLifecycle(this, 131072 /* OnDestroy */);\n        this._destroyListeners.forEach(function (listener) { return listener(); });\n    };\n    NgModuleRef_.prototype.onDestroy = function (callback) { this._destroyListeners.push(callback); };\n    return NgModuleRef_;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar RendererV1TokenKey = tokenKey(Renderer);\nvar Renderer2TokenKey = tokenKey(Renderer2);\nvar ElementRefTokenKey = tokenKey(ElementRef);\nvar ViewContainerRefTokenKey = tokenKey(ViewContainerRef);\nvar TemplateRefTokenKey = tokenKey(TemplateRef);\nvar ChangeDetectorRefTokenKey = tokenKey(ChangeDetectorRef);\nvar InjectorRefTokenKey = tokenKey(Injector);\nvar INJECTORRefTokenKey = tokenKey(INJECTOR);\nfunction directiveDef(checkIndex, flags, matchedQueries, childCount, ctor, deps, props, outputs) {\n    var bindings = [];\n    if (props) {\n        for (var prop in props) {\n            var _a = __read(props[prop], 2), bindingIndex = _a[0], nonMinifiedName = _a[1];\n            bindings[bindingIndex] = {\n                flags: 8 /* TypeProperty */,\n                name: prop, nonMinifiedName: nonMinifiedName,\n                ns: null,\n                securityContext: null,\n                suffix: null\n            };\n        }\n    }\n    var outputDefs = [];\n    if (outputs) {\n        for (var propName in outputs) {\n            outputDefs.push({ type: 1 /* DirectiveOutput */, propName: propName, target: null, eventName: outputs[propName] });\n        }\n    }\n    flags |= 16384 /* TypeDirective */;\n    return _def(checkIndex, flags, matchedQueries, childCount, ctor, ctor, deps, bindings, outputDefs);\n}\nfunction pipeDef(flags, ctor, deps) {\n    flags |= 16 /* TypePipe */;\n    return _def(-1, flags, null, 0, ctor, ctor, deps);\n}\nfunction providerDef(flags, matchedQueries, token, value, deps) {\n    return _def(-1, flags, matchedQueries, 0, token, value, deps);\n}\nfunction _def(checkIndex, flags, matchedQueriesDsl, childCount, token, value, deps, bindings, outputs) {\n    var _a = splitMatchedQueriesDsl(matchedQueriesDsl), matchedQueries = _a.matchedQueries, references = _a.references, matchedQueryIds = _a.matchedQueryIds;\n    if (!outputs) {\n        outputs = [];\n    }\n    if (!bindings) {\n        bindings = [];\n    }\n    // Need to resolve forwardRefs as e.g. for `useValue` we\n    // lowered the expression and then stopped evaluating it,\n    // i.e. also didn't unwrap it.\n    value = resolveForwardRef(value);\n    var depDefs = splitDepsDsl(deps, stringify(token));\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: flags,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0, matchedQueries: matchedQueries, matchedQueryIds: matchedQueryIds, references: references,\n        ngContentIndex: -1, childCount: childCount, bindings: bindings,\n        bindingFlags: calcBindingFlags(bindings), outputs: outputs,\n        element: null,\n        provider: { token: token, value: value, deps: depDefs },\n        text: null,\n        query: null,\n        ngContent: null\n    };\n}\nfunction createProviderInstance(view, def) {\n    return _createProviderInstance(view, def);\n}\nfunction createPipeInstance(view, def) {\n    // deps are looked up from component.\n    var compView = view;\n    while (compView.parent && !isComponentView(compView)) {\n        compView = compView.parent;\n    }\n    // pipes can see the private services of the component\n    var allowPrivateServices = true;\n    // pipes are always eager and classes!\n    return createClass((compView.parent), (viewParentEl(compView)), allowPrivateServices, def.provider.value, def.provider.deps);\n}\nfunction createDirectiveInstance(view, def) {\n    // components can see other private services, other directives can't.\n    var allowPrivateServices = (def.flags & 32768 /* Component */) > 0;\n    // directives are always eager and classes!\n    var instance = createClass(view, (def.parent), allowPrivateServices, def.provider.value, def.provider.deps);\n    if (def.outputs.length) {\n        for (var i = 0; i < def.outputs.length; i++) {\n            var output = def.outputs[i];\n            var subscription = instance[output.propName].subscribe(eventHandlerClosure(view, def.parent.nodeIndex, output.eventName));\n            view.disposables[def.outputIndex + i] = subscription.unsubscribe.bind(subscription);\n        }\n    }\n    return instance;\n}\nfunction eventHandlerClosure(view, index, eventName) {\n    return function (event) { return dispatchEvent(view, index, eventName, event); };\n}\nfunction checkAndUpdateDirectiveInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var providerData = asProviderData(view, def.nodeIndex);\n    var directive = providerData.instance;\n    var changed = false;\n    var changes = (undefined);\n    var 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 ((def.flags & 65536 /* OnInit */) &&\n        shouldCallLifecycleInitHook(view, 256 /* InitState_CallingOnInit */, def.nodeIndex)) {\n        directive.ngOnInit();\n    }\n    if (def.flags & 262144 /* DoCheck */) {\n        directive.ngDoCheck();\n    }\n    return changed;\n}\nfunction checkAndUpdateDirectiveDynamic(view, def, values) {\n    var providerData = asProviderData(view, def.nodeIndex);\n    var directive = providerData.instance;\n    var changed = false;\n    var changes = (undefined);\n    for (var 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 ((def.flags & 65536 /* OnInit */) &&\n        shouldCallLifecycleInitHook(view, 256 /* InitState_CallingOnInit */, def.nodeIndex)) {\n        directive.ngOnInit();\n    }\n    if (def.flags & 262144 /* DoCheck */) {\n        directive.ngDoCheck();\n    }\n    return changed;\n}\nfunction _createProviderInstance(view, def) {\n    // private services can see other private services\n    var allowPrivateServices = (def.flags & 8192 /* PrivateProvider */) > 0;\n    var providerDef = def.provider;\n    switch (def.flags & 201347067 /* Types */) {\n        case 512 /* TypeClassProvider */:\n            return createClass(view, (def.parent), allowPrivateServices, providerDef.value, providerDef.deps);\n        case 1024 /* TypeFactoryProvider */:\n            return callFactory(view, (def.parent), allowPrivateServices, providerDef.value, providerDef.deps);\n        case 2048 /* TypeUseExistingProvider */:\n            return resolveDep(view, (def.parent), allowPrivateServices, providerDef.deps[0]);\n        case 256 /* TypeValueProvider */:\n            return providerDef.value;\n    }\n}\nfunction createClass(view, elDef, allowPrivateServices, ctor, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return new ctor();\n        case 1:\n            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n        case 2:\n            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]));\n        case 3:\n            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]), resolveDep(view, elDef, allowPrivateServices, deps[2]));\n        default:\n            var depValues = new Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);\n            }\n            return new (ctor.bind.apply(ctor, __spread([void 0], depValues)))();\n    }\n}\nfunction callFactory(view, elDef, allowPrivateServices, factory, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return factory();\n        case 1:\n            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n        case 2:\n            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]));\n        case 3:\n            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]), resolveDep(view, elDef, allowPrivateServices, deps[2]));\n        default:\n            var depValues = Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);\n            }\n            return factory.apply(void 0, __spread(depValues));\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)\nvar NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};\nfunction resolveDep(view, elDef, allowPrivateServices, depDef, notFoundValue) {\n    if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n    if (depDef.flags & 8 /* Value */) {\n        return depDef.token;\n    }\n    var startView = view;\n    if (depDef.flags & 2 /* Optional */) {\n        notFoundValue = null;\n    }\n    var tokenKey$$1 = depDef.tokenKey;\n    if (tokenKey$$1 === 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 && elDef.element.componentView);\n    }\n    if (elDef && (depDef.flags & 1 /* SkipSelf */)) {\n        allowPrivateServices = false;\n        elDef = (elDef.parent);\n    }\n    var searchView = view;\n    while (searchView) {\n        if (elDef) {\n            switch (tokenKey$$1) {\n                case RendererV1TokenKey: {\n                    var compView = findCompView(searchView, elDef, allowPrivateServices);\n                    return createRendererV1(compView);\n                }\n                case Renderer2TokenKey: {\n                    var compView = findCompView(searchView, elDef, allowPrivateServices);\n                    return compView.renderer;\n                }\n                case ElementRefTokenKey:\n                    return new ElementRef(asElementData(searchView, elDef.nodeIndex).renderElement);\n                case ViewContainerRefTokenKey:\n                    return asElementData(searchView, elDef.nodeIndex).viewContainer;\n                case TemplateRefTokenKey: {\n                    if (elDef.element.template) {\n                        return asElementData(searchView, elDef.nodeIndex).template;\n                    }\n                    break;\n                }\n                case ChangeDetectorRefTokenKey: {\n                    var cdView = findCompView(searchView, elDef, allowPrivateServices);\n                    return createChangeDetectorRef(cdView);\n                }\n                case InjectorRefTokenKey:\n                case INJECTORRefTokenKey:\n                    return createInjector$1(searchView, elDef);\n                default:\n                    var providerDef_1 = (allowPrivateServices ? elDef.element.allProviders :\n                        elDef.element.publicProviders)[tokenKey$$1];\n                    if (providerDef_1) {\n                        var providerData = asProviderData(searchView, providerDef_1.nodeIndex);\n                        if (!providerData) {\n                            providerData = { instance: _createProviderInstance(searchView, providerDef_1) };\n                            searchView.nodes[providerDef_1.nodeIndex] = providerData;\n                        }\n                        return providerData.instance;\n                    }\n            }\n        }\n        allowPrivateServices = isComponentView(searchView);\n        elDef = (viewParentEl(searchView));\n        searchView = (searchView.parent);\n        if (depDef.flags & 4 /* Self */) {\n            searchView = null;\n        }\n    }\n    var value = startView.root.injector.get(depDef.token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);\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    return startView.root.ngModule.injector.get(depDef.token, notFoundValue);\n}\nfunction findCompView(view, elDef, allowPrivateServices) {\n    var compView;\n    if (allowPrivateServices) {\n        compView = asElementData(view, elDef.nodeIndex).componentView;\n    }\n    else {\n        compView = view;\n        while (compView.parent && !isComponentView(compView)) {\n            compView = compView.parent;\n        }\n    }\n    return compView;\n}\nfunction updateProp(view, providerData, def, bindingIdx, value, changes) {\n    if (def.flags & 32768 /* Component */) {\n        var compView = asElementData(view, def.parent.nodeIndex).componentView;\n        if (compView.def.flags & 2 /* OnPush */) {\n            compView.state |= 8 /* ChecksEnabled */;\n        }\n    }\n    var binding = def.bindings[bindingIdx];\n    var propName = (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 & 524288 /* OnChanges */) {\n        changes = changes || {};\n        var oldValue = WrappedValue.unwrap(view.oldValues[def.bindingIndex + bindingIdx]);\n        var binding_1 = def.bindings[bindingIdx];\n        changes[binding_1.nonMinifiedName] =\n            new SimpleChange(oldValue, value, (view.state & 2 /* FirstCheck */) !== 0);\n    }\n    view.oldValues[def.bindingIndex + bindingIdx] = value;\n    return changes;\n}\n// This function calls the ngAfterContentCheck, ngAfterContentInit,\n// ngAfterViewCheck, and ngAfterViewInit lifecycle hooks (depending on the node\n// flags in lifecycle). Unlike ngDoCheck, ngOnChanges and ngOnInit, which are\n// called during a pre-order traversal of the view tree (that is calling the\n// parent hooks before the child hooks) these events are sent in using a\n// post-order traversal of the tree (children before parents). This changes the\n// meaning of initIndex in the view state. For ngOnInit, initIndex tracks the\n// expected nodeIndex which a ngOnInit should be called. When sending\n// ngAfterContentInit and ngAfterViewInit it is the expected count of\n// ngAfterContentInit or ngAfterViewInit methods that have been called. This\n// ensure that despite being called recursively or after picking up after an\n// exception, the ngAfterContentInit or ngAfterViewInit will be called on the\n// correct nodes. Consider for example, the following (where E is an element\n// and D is a directive)\n//  Tree:       pre-order index  post-order index\n//    E1        0                6\n//      E2      1                1\n//       D3     2                0\n//      E4      3                5\n//       E5     4                4\n//        E6    5                2\n//        E7    6                3\n// As can be seen, the post-order index has an unclear relationship to the\n// pre-order index (postOrderIndex === preOrderIndex - parentCount +\n// childCount). Since number of calls to ngAfterContentInit and ngAfterViewInit\n// are stable (will be the same for the same view regardless of exceptions or\n// recursion) we just need to count them which will roughly correspond to the\n// post-order index (it skips elements and directives that do not have\n// lifecycle hooks).\n//\n// For example, if an exception is raised in the E6.onAfterViewInit() the\n// initIndex is left at 3 (by shouldCallLifecycleInitHook() which set it to\n// initIndex + 1). When checkAndUpdateView() is called again D3, E2 and E6 will\n// not have their ngAfterViewInit() called but, starting with E7, the rest of\n// the view will begin getting ngAfterViewInit() called until a check and\n// pass is complete.\n//\n// This algorthim also handles recursion. Consider if E4's ngAfterViewInit()\n// indirectly calls E1's ChangeDetectorRef.detectChanges(). The expected\n// initIndex is set to 6, the recusive checkAndUpdateView() starts walk again.\n// D3, E2, E6, E7, E5 and E4 are skipped, ngAfterViewInit() is called on E1.\n// When the recursion returns the initIndex will be 7 so E1 is skipped as it\n// has already been called in the recursively called checkAnUpdateView().\nfunction callLifecycleHooksChildrenFirst(view, lifecycles) {\n    if (!(view.def.nodeFlags & lifecycles)) {\n        return;\n    }\n    var nodes = view.def.nodes;\n    var initIndex = 0;\n    for (var i = 0; i < nodes.length; i++) {\n        var nodeDef = nodes[i];\n        var parent_1 = nodeDef.parent;\n        if (!parent_1 && nodeDef.flags & lifecycles) {\n            // matching root node (e.g. a pipe)\n            callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);\n        }\n        if ((nodeDef.childFlags & lifecycles) === 0) {\n            // no child matches one of the lifecycles\n            i += nodeDef.childCount;\n        }\n        while (parent_1 && (parent_1.flags & 1 /* TypeElement */) &&\n            i === parent_1.nodeIndex + parent_1.childCount) {\n            // last child of an element\n            if (parent_1.directChildFlags & lifecycles) {\n                initIndex = callElementProvidersLifecycles(view, parent_1, lifecycles, initIndex);\n            }\n            parent_1 = parent_1.parent;\n        }\n    }\n}\nfunction callElementProvidersLifecycles(view, elDef, lifecycles, initIndex) {\n    for (var i = elDef.nodeIndex + 1; i <= elDef.nodeIndex + elDef.childCount; i++) {\n        var nodeDef = view.def.nodes[i];\n        if (nodeDef.flags & lifecycles) {\n            callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);\n        }\n        // only visit direct children\n        i += nodeDef.childCount;\n    }\n    return initIndex;\n}\nfunction callProviderLifecycles(view, index, lifecycles, initIndex) {\n    var providerData = asProviderData(view, index);\n    if (!providerData) {\n        return;\n    }\n    var provider = providerData.instance;\n    if (!provider) {\n        return;\n    }\n    Services.setCurrentNode(view, index);\n    if (lifecycles & 1048576 /* AfterContentInit */ &&\n        shouldCallLifecycleInitHook(view, 512 /* InitState_CallingAfterContentInit */, initIndex)) {\n        provider.ngAfterContentInit();\n    }\n    if (lifecycles & 2097152 /* AfterContentChecked */) {\n        provider.ngAfterContentChecked();\n    }\n    if (lifecycles & 4194304 /* AfterViewInit */ &&\n        shouldCallLifecycleInitHook(view, 768 /* InitState_CallingAfterViewInit */, initIndex)) {\n        provider.ngAfterViewInit();\n    }\n    if (lifecycles & 8388608 /* AfterViewChecked */) {\n        provider.ngAfterViewChecked();\n    }\n    if (lifecycles & 131072 /* OnDestroy */) {\n        provider.ngOnDestroy();\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 */\nfunction queryDef(flags, id, bindings) {\n    var bindingDefs = [];\n    for (var propName in bindings) {\n        var bindingType = bindings[propName];\n        bindingDefs.push({ propName: propName, bindingType: bindingType });\n    }\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        // TODO(vicb): check\n        checkIndex: -1, flags: 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: id, filterId: filterQueryId(id), bindings: bindingDefs },\n        ngContent: null\n    };\n}\nfunction createQuery() {\n    return new QueryList();\n}\nfunction dirtyParentQueries(view) {\n    var queryIds = view.def.nodeMatchedQueries;\n    while (view.parent && isEmbeddedView(view)) {\n        var tplDef = (view.parentNodeDef);\n        view = view.parent;\n        // content queries\n        var end = tplDef.nodeIndex + tplDef.childCount;\n        for (var i = 0; i <= end; i++) {\n            var nodeDef = view.def.nodes[i];\n            if ((nodeDef.flags & 67108864 /* TypeContentQuery */) &&\n                (nodeDef.flags & 536870912 /* DynamicQuery */) &&\n                (nodeDef.query.filterId & queryIds) === nodeDef.query.filterId) {\n                asQueryList(view, i).setDirty();\n            }\n            if ((nodeDef.flags & 1 /* TypeElement */ && i + nodeDef.childCount < tplDef.nodeIndex) ||\n                !(nodeDef.childFlags & 67108864 /* TypeContentQuery */) ||\n                !(nodeDef.childFlags & 536870912 /* DynamicQuery */)) {\n                // skip elements that don't contain the template element or no query.\n                i += nodeDef.childCount;\n            }\n        }\n    }\n    // view queries\n    if (view.def.nodeFlags & 134217728 /* TypeViewQuery */) {\n        for (var i = 0; i < view.def.nodes.length; i++) {\n            var nodeDef = view.def.nodes[i];\n            if ((nodeDef.flags & 134217728 /* TypeViewQuery */) && (nodeDef.flags & 536870912 /* DynamicQuery */)) {\n                asQueryList(view, i).setDirty();\n            }\n            // only visit the root nodes\n            i += nodeDef.childCount;\n        }\n    }\n}\nfunction checkAndUpdateQuery(view, nodeDef) {\n    var queryList = asQueryList(view, nodeDef.nodeIndex);\n    if (!queryList.dirty) {\n        return;\n    }\n    var directiveInstance;\n    var newValues = (undefined);\n    if (nodeDef.flags & 67108864 /* TypeContentQuery */) {\n        var elementDef = (nodeDef.parent.parent);\n        newValues = calcQueryValues(view, elementDef.nodeIndex, elementDef.nodeIndex + elementDef.childCount, (nodeDef.query), []);\n        directiveInstance = asProviderData(view, nodeDef.parent.nodeIndex).instance;\n    }\n    else if (nodeDef.flags & 134217728 /* TypeViewQuery */) {\n        newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, (nodeDef.query), []);\n        directiveInstance = view.component;\n    }\n    queryList.reset(newValues);\n    var bindings = nodeDef.query.bindings;\n    var notify = false;\n    for (var i = 0; i < bindings.length; i++) {\n        var binding = bindings[i];\n        var boundValue = void 0;\n        switch (binding.bindingType) {\n            case 0 /* First */:\n                boundValue = queryList.first;\n                break;\n            case 1 /* All */:\n                boundValue = queryList;\n                notify = true;\n                break;\n        }\n        directiveInstance[binding.propName] = boundValue;\n    }\n    if (notify) {\n        queryList.notifyOnChanges();\n    }\n}\nfunction calcQueryValues(view, startIndex, endIndex, queryDef, values) {\n    for (var i = startIndex; i <= endIndex; i++) {\n        var nodeDef = view.def.nodes[i];\n        var valueType = nodeDef.matchedQueries[queryDef.id];\n        if (valueType != null) {\n            values.push(getQueryValue(view, nodeDef, valueType));\n        }\n        if (nodeDef.flags & 1 /* TypeElement */ && nodeDef.element.template &&\n            (nodeDef.element.template.nodeMatchedQueries & queryDef.filterId) ===\n                queryDef.filterId) {\n            var elementData = asElementData(view, i);\n            // check embedded views that were attached at the place of their template,\n            // but process child nodes first if some match the query (see issue #16568)\n            if ((nodeDef.childMatchedQueries & queryDef.filterId) === queryDef.filterId) {\n                calcQueryValues(view, i + 1, i + nodeDef.childCount, queryDef, values);\n                i += nodeDef.childCount;\n            }\n            if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n                var embeddedViews = elementData.viewContainer._embeddedViews;\n                for (var k = 0; k < embeddedViews.length; k++) {\n                    var embeddedView = embeddedViews[k];\n                    var dvc = declaredViewContainer(embeddedView);\n                    if (dvc && dvc === elementData) {\n                        calcQueryValues(embeddedView, 0, embeddedView.def.nodes.length - 1, queryDef, values);\n                    }\n                }\n            }\n            var projectedViews = elementData.template._projectedViews;\n            if (projectedViews) {\n                for (var k = 0; k < projectedViews.length; k++) {\n                    var 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}\nfunction getQueryValue(view, nodeDef, queryValueType) {\n    if (queryValueType != null) {\n        // a match\n        switch (queryValueType) {\n            case 1 /* RenderElement */:\n                return asElementData(view, nodeDef.nodeIndex).renderElement;\n            case 0 /* ElementRef */:\n                return new ElementRef(asElementData(view, nodeDef.nodeIndex).renderElement);\n            case 2 /* TemplateRef */:\n                return asElementData(view, nodeDef.nodeIndex).template;\n            case 3 /* ViewContainerRef */:\n                return asElementData(view, nodeDef.nodeIndex).viewContainer;\n            case 4 /* Provider */:\n                return asProviderData(view, nodeDef.nodeIndex).instance;\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 */\nfunction ngContentDef(ngContentIndex, index) {\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: -1,\n        flags: 8 /* TypeNgContent */,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0,\n        matchedQueries: {},\n        matchedQueryIds: 0,\n        references: {}, ngContentIndex: 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: index }\n    };\n}\nfunction appendNgContent(view, renderHost, def) {\n    var parentEl = getParentRenderElement(view, renderHost, def);\n    if (!parentEl) {\n        // Nothing to do if there is no parent element.\n        return;\n    }\n    var ngContentIndex = def.ngContent.index;\n    visitProjectedRenderNodes(view, ngContentIndex, 1 /* AppendChild */, parentEl, null, undefined);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction purePipeDef(checkIndex, argCount) {\n    // argCount + 1 to include the pipe as first arg\n    return _pureExpressionDef(128 /* TypePurePipe */, checkIndex, new Array(argCount + 1));\n}\nfunction pureArrayDef(checkIndex, argCount) {\n    return _pureExpressionDef(32 /* TypePureArray */, checkIndex, new Array(argCount));\n}\nfunction pureObjectDef(checkIndex, propToIndex) {\n    var keys = Object.keys(propToIndex);\n    var nbKeys = keys.length;\n    var propertyNames = new Array(nbKeys);\n    for (var i = 0; i < nbKeys; i++) {\n        var key = keys[i];\n        var index = propToIndex[key];\n        propertyNames[index] = key;\n    }\n    return _pureExpressionDef(64 /* TypePureObject */, checkIndex, propertyNames);\n}\nfunction _pureExpressionDef(flags, checkIndex, propertyNames) {\n    var bindings = new Array(propertyNames.length);\n    for (var i = 0; i < propertyNames.length; i++) {\n        var prop = propertyNames[i];\n        bindings[i] = {\n            flags: 8 /* 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        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: flags,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0,\n        matchedQueries: {},\n        matchedQueryIds: 0,\n        references: {},\n        ngContentIndex: -1,\n        childCount: 0, bindings: bindings,\n        bindingFlags: calcBindingFlags(bindings),\n        outputs: [],\n        element: null,\n        provider: null,\n        text: null,\n        query: null,\n        ngContent: null\n    };\n}\nfunction createPureExpression(view, def) {\n    return { value: undefined };\n}\nfunction checkAndUpdatePureExpressionInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var bindings = def.bindings;\n    var changed = false;\n    var bindLen = bindings.length;\n    if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0))\n        changed = true;\n    if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1))\n        changed = true;\n    if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2))\n        changed = true;\n    if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3))\n        changed = true;\n    if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4))\n        changed = true;\n    if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5))\n        changed = true;\n    if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6))\n        changed = true;\n    if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7))\n        changed = true;\n    if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8))\n        changed = true;\n    if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9))\n        changed = true;\n    if (changed) {\n        var data = asPureExpressionData(view, def.nodeIndex);\n        var value = void 0;\n        switch (def.flags & 201347067 /* Types */) {\n            case 32 /* TypePureArray */:\n                value = new Array(bindings.length);\n                if (bindLen > 0)\n                    value[0] = v0;\n                if (bindLen > 1)\n                    value[1] = v1;\n                if (bindLen > 2)\n                    value[2] = v2;\n                if (bindLen > 3)\n                    value[3] = v3;\n                if (bindLen > 4)\n                    value[4] = v4;\n                if (bindLen > 5)\n                    value[5] = v5;\n                if (bindLen > 6)\n                    value[6] = v6;\n                if (bindLen > 7)\n                    value[7] = v7;\n                if (bindLen > 8)\n                    value[8] = v8;\n                if (bindLen > 9)\n                    value[9] = v9;\n                break;\n            case 64 /* TypePureObject */:\n                value = {};\n                if (bindLen > 0)\n                    value[bindings[0].name] = v0;\n                if (bindLen > 1)\n                    value[bindings[1].name] = v1;\n                if (bindLen > 2)\n                    value[bindings[2].name] = v2;\n                if (bindLen > 3)\n                    value[bindings[3].name] = v3;\n                if (bindLen > 4)\n                    value[bindings[4].name] = v4;\n                if (bindLen > 5)\n                    value[bindings[5].name] = v5;\n                if (bindLen > 6)\n                    value[bindings[6].name] = v6;\n                if (bindLen > 7)\n                    value[bindings[7].name] = v7;\n                if (bindLen > 8)\n                    value[bindings[8].name] = v8;\n                if (bindLen > 9)\n                    value[bindings[9].name] = v9;\n                break;\n            case 128 /* TypePurePipe */:\n                var 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}\nfunction checkAndUpdatePureExpressionDynamic(view, def, values) {\n    var bindings = def.bindings;\n    var changed = false;\n    for (var 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        var data = asPureExpressionData(view, def.nodeIndex);\n        var value = void 0;\n        switch (def.flags & 201347067 /* Types */) {\n            case 32 /* TypePureArray */:\n                value = values;\n                break;\n            case 64 /* TypePureObject */:\n                value = {};\n                for (var i = 0; i < values.length; i++) {\n                    value[bindings[i].name] = values[i];\n                }\n                break;\n            case 128 /* TypePurePipe */:\n                var pipe = values[0];\n                var params = values.slice(1);\n                value = pipe.transform.apply(pipe, __spread(params));\n                break;\n        }\n        data.value = value;\n    }\n    return changed;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction textDef(checkIndex, ngContentIndex, staticText) {\n    var bindings = new Array(staticText.length - 1);\n    for (var i = 1; i < staticText.length; i++) {\n        bindings[i - 1] = {\n            flags: 8 /* TypeProperty */,\n            name: null,\n            ns: null,\n            nonMinifiedName: null,\n            securityContext: null,\n            suffix: staticText[i],\n        };\n    }\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: 2 /* TypeText */,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0,\n        matchedQueries: {},\n        matchedQueryIds: 0,\n        references: {}, ngContentIndex: ngContentIndex,\n        childCount: 0, bindings: bindings,\n        bindingFlags: 8 /* TypeProperty */,\n        outputs: [],\n        element: null,\n        provider: null,\n        text: { prefix: staticText[0] },\n        query: null,\n        ngContent: null,\n    };\n}\nfunction createText(view, renderHost, def) {\n    var renderNode$$1;\n    var renderer = view.renderer;\n    renderNode$$1 = renderer.createText(def.text.prefix);\n    var parentEl = getParentRenderElement(view, renderHost, def);\n    if (parentEl) {\n        renderer.appendChild(parentEl, renderNode$$1);\n    }\n    return { renderText: renderNode$$1 };\n}\nfunction checkAndUpdateTextInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var changed = false;\n    var bindings = def.bindings;\n    var bindLen = bindings.length;\n    if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0))\n        changed = true;\n    if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1))\n        changed = true;\n    if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2))\n        changed = true;\n    if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3))\n        changed = true;\n    if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4))\n        changed = true;\n    if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5))\n        changed = true;\n    if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6))\n        changed = true;\n    if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7))\n        changed = true;\n    if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8))\n        changed = true;\n    if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9))\n        changed = true;\n    if (changed) {\n        var value = def.text.prefix;\n        if (bindLen > 0)\n            value += _addInterpolationPart(v0, bindings[0]);\n        if (bindLen > 1)\n            value += _addInterpolationPart(v1, bindings[1]);\n        if (bindLen > 2)\n            value += _addInterpolationPart(v2, bindings[2]);\n        if (bindLen > 3)\n            value += _addInterpolationPart(v3, bindings[3]);\n        if (bindLen > 4)\n            value += _addInterpolationPart(v4, bindings[4]);\n        if (bindLen > 5)\n            value += _addInterpolationPart(v5, bindings[5]);\n        if (bindLen > 6)\n            value += _addInterpolationPart(v6, bindings[6]);\n        if (bindLen > 7)\n            value += _addInterpolationPart(v7, bindings[7]);\n        if (bindLen > 8)\n            value += _addInterpolationPart(v8, bindings[8]);\n        if (bindLen > 9)\n            value += _addInterpolationPart(v9, bindings[9]);\n        var renderNode$$1 = asTextData(view, def.nodeIndex).renderText;\n        view.renderer.setValue(renderNode$$1, value);\n    }\n    return changed;\n}\nfunction checkAndUpdateTextDynamic(view, def, values) {\n    var bindings = def.bindings;\n    var changed = false;\n    for (var 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        var value = '';\n        for (var i = 0; i < values.length; i++) {\n            value = value + _addInterpolationPart(values[i], bindings[i]);\n        }\n        value = def.text.prefix + value;\n        var renderNode$$1 = asTextData(view, def.nodeIndex).renderText;\n        view.renderer.setValue(renderNode$$1, value);\n    }\n    return changed;\n}\nfunction _addInterpolationPart(value, binding) {\n    var valueStr = value != null ? value.toString() : '';\n    return valueStr + binding.suffix;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction viewDef(flags, nodes, updateDirectives, updateRenderer) {\n    // clone nodes and set auto calculated values\n    var viewBindingCount = 0;\n    var viewDisposableCount = 0;\n    var viewNodeFlags = 0;\n    var viewRootNodeFlags = 0;\n    var viewMatchedQueries = 0;\n    var currentParent = null;\n    var currentRenderParent = null;\n    var currentElementHasPublicProviders = false;\n    var currentElementHasPrivateProviders = false;\n    var lastRenderRootNode = null;\n    for (var i = 0; i < nodes.length; i++) {\n        var node = nodes[i];\n        node.nodeIndex = i;\n        node.parent = currentParent;\n        node.bindingIndex = viewBindingCount;\n        node.outputIndex = viewDisposableCount;\n        node.renderParent = currentRenderParent;\n        viewNodeFlags |= node.flags;\n        viewMatchedQueries |= node.matchedQueryIds;\n        if (node.element) {\n            var elDef = node.element;\n            elDef.publicProviders =\n                currentParent ? 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            if (node.element.template) {\n                viewMatchedQueries |= node.element.template.nodeMatchedQueries;\n            }\n        }\n        validateNode(currentParent, node, nodes.length);\n        viewBindingCount += node.bindings.length;\n        viewDisposableCount += node.outputs.length;\n        if (!currentRenderParent && (node.flags & 3 /* CatRenderNode */)) {\n            lastRenderRootNode = node;\n        }\n        if (node.flags & 20224 /* CatProvider */) {\n            if (!currentElementHasPublicProviders) {\n                currentElementHasPublicProviders = true;\n                // Use prototypical inheritance to not get O(n^2) complexity...\n                // Use prototypical inheritance to not get O(n^2) complexity...\n                currentParent.element.publicProviders =\n                    Object.create(currentParent.element.publicProviders);\n                currentParent.element.allProviders = currentParent.element.publicProviders;\n            }\n            var isPrivateService = (node.flags & 8192 /* PrivateProvider */) !== 0;\n            var isComponent = (node.flags & 32768 /* Component */) !== 0;\n            if (!isPrivateService || isComponent) {\n                currentParent.element.publicProviders[tokenKey(node.provider.token)] = node;\n            }\n            else {\n                if (!currentElementHasPrivateProviders) {\n                    currentElementHasPrivateProviders = true;\n                    // Use prototypical inheritance to not get O(n^2) complexity...\n                    // Use prototypical inheritance to not get O(n^2) complexity...\n                    currentParent.element.allProviders =\n                        Object.create(currentParent.element.publicProviders);\n                }\n                currentParent.element.allProviders[tokenKey(node.provider.token)] = node;\n            }\n            if (isComponent) {\n                currentParent.element.componentProvider = node;\n            }\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        }\n        else {\n            viewRootNodeFlags |= node.flags;\n        }\n        if (node.childCount > 0) {\n            currentParent = node;\n            if (!isNgContainer(node)) {\n                currentRenderParent = node;\n            }\n        }\n        else {\n            // When the current node has no children, check if it is the last children of its parent.\n            // When it is, propagate the flags up.\n            // The loop is required because an element could be the last transitive children of several\n            // elements. We loop to either the root or the highest opened element (= with remaining\n            // children)\n            while (currentParent && i === currentParent.nodeIndex + currentParent.childCount) {\n                var newParent = currentParent.parent;\n                if (newParent) {\n                    newParent.childFlags |= currentParent.childFlags;\n                    newParent.childMatchedQueries |= currentParent.childMatchedQueries;\n                }\n                currentParent = newParent;\n                // We also need to update the render parent & account for ng-container\n                if (currentParent && isNgContainer(currentParent)) {\n                    currentRenderParent = currentParent.renderParent;\n                }\n                else {\n                    currentRenderParent = currentParent;\n                }\n            }\n        }\n    }\n    var handleEvent = function (view, nodeIndex, eventName, event) {\n        return nodes[nodeIndex].element.handleEvent(view, eventName, event);\n    };\n    return {\n        // Will be filled later...\n        factory: null,\n        nodeFlags: viewNodeFlags,\n        rootNodeFlags: viewRootNodeFlags,\n        nodeMatchedQueries: viewMatchedQueries, flags: flags,\n        nodes: nodes,\n        updateDirectives: updateDirectives || NOOP,\n        updateRenderer: updateRenderer || NOOP, handleEvent: handleEvent,\n        bindingCount: viewBindingCount,\n        outputCount: viewDisposableCount, lastRenderRootNode: lastRenderRootNode\n    };\n}\nfunction isNgContainer(node) {\n    return (node.flags & 1 /* TypeElement */) !== 0 && node.element.name === null;\n}\nfunction validateNode(parent, node, nodeCount) {\n    var 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 & 16777216 /* EmbeddedViews */) {\n            throw new Error(\"Illegal State: Last root node of a template can't have embedded views, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n    if (node.flags & 20224 /* CatProvider */) {\n        var parentFlags = parent ? parent.flags : 0;\n        if ((parentFlags & 1 /* TypeElement */) === 0) {\n            throw new Error(\"Illegal State: StaticProvider/Directive nodes need to be children of elements or anchors, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n    if (node.query) {\n        if (node.flags & 67108864 /* TypeContentQuery */ &&\n            (!parent || (parent.flags & 16384 /* TypeDirective */) === 0)) {\n            throw new Error(\"Illegal State: Content Query nodes need to be children of directives, at index \" + node.nodeIndex + \"!\");\n        }\n        if (node.flags & 134217728 /* TypeViewQuery */ && parent) {\n            throw new Error(\"Illegal State: View Query nodes have to be top level nodes, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n    if (node.childCount) {\n        var parentEnd = parent ? parent.nodeIndex + parent.childCount : nodeCount - 1;\n        if (node.nodeIndex <= parentEnd && node.nodeIndex + node.childCount > parentEnd) {\n            throw new Error(\"Illegal State: childCount of node leads outside of parent, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n}\nfunction createEmbeddedView(parent, anchorDef$$1, viewDef, context) {\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    var view = createView(parent.root, parent.renderer, parent, anchorDef$$1, viewDef);\n    initView(view, parent.component, context);\n    createViewNodes(view);\n    return view;\n}\nfunction createRootView(root, def, context) {\n    var view = createView(root, root.renderer, null, null, def);\n    initView(view, context, context);\n    createViewNodes(view);\n    return view;\n}\nfunction createComponentView(parentView, nodeDef, viewDef, hostElement) {\n    var rendererType = nodeDef.element.componentRendererType;\n    var compRenderer;\n    if (!rendererType) {\n        compRenderer = parentView.root.renderer;\n    }\n    else {\n        compRenderer = parentView.root.rendererFactory.createRenderer(hostElement, rendererType);\n    }\n    return createView(parentView.root, compRenderer, parentView, nodeDef.element.componentProvider, viewDef);\n}\nfunction createView(root, renderer, parent, parentNodeDef, def) {\n    var nodes = new Array(def.nodes.length);\n    var disposables = def.outputCount ? new Array(def.outputCount) : null;\n    var view = {\n        def: def,\n        parent: parent,\n        viewContainerParent: null, parentNodeDef: parentNodeDef,\n        context: null,\n        component: null, nodes: nodes,\n        state: 13 /* CatInit */, root: root, renderer: renderer,\n        oldValues: new Array(def.bindingCount), disposables: disposables,\n        initIndex: -1\n    };\n    return view;\n}\nfunction initView(view, component, context) {\n    view.component = component;\n    view.context = context;\n}\nfunction createViewNodes(view) {\n    var renderHost;\n    if (isComponentView(view)) {\n        var hostDef = view.parentNodeDef;\n        renderHost = asElementData((view.parent), hostDef.parent.nodeIndex).renderElement;\n    }\n    var def = view.def;\n    var nodes = view.nodes;\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        Services.setCurrentNode(view, i);\n        var nodeData = void 0;\n        switch (nodeDef.flags & 201347067 /* Types */) {\n            case 1 /* TypeElement */:\n                var el = createElement(view, renderHost, nodeDef);\n                var componentView = (undefined);\n                if (nodeDef.flags & 33554432 /* ComponentView */) {\n                    var compViewDef = resolveDefinition((nodeDef.element.componentView));\n                    componentView = Services.createComponentView(view, nodeDef, compViewDef, el);\n                }\n                listenToElementOutputs(view, componentView, nodeDef, el);\n                nodeData = {\n                    renderElement: el,\n                    componentView: componentView,\n                    viewContainer: null,\n                    template: nodeDef.element.template ? createTemplateData(view, nodeDef) : undefined\n                };\n                if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n                    nodeData.viewContainer = createViewContainerData(view, nodeDef, nodeData);\n                }\n                break;\n            case 2 /* TypeText */:\n                nodeData = createText(view, renderHost, nodeDef);\n                break;\n            case 512 /* TypeClassProvider */:\n            case 1024 /* TypeFactoryProvider */:\n            case 2048 /* TypeUseExistingProvider */:\n            case 256 /* TypeValueProvider */: {\n                nodeData = nodes[i];\n                if (!nodeData && !(nodeDef.flags & 4096 /* LazyProvider */)) {\n                    var instance = createProviderInstance(view, nodeDef);\n                    nodeData = { instance: instance };\n                }\n                break;\n            }\n            case 16 /* TypePipe */: {\n                var instance = createPipeInstance(view, nodeDef);\n                nodeData = { instance: instance };\n                break;\n            }\n            case 16384 /* TypeDirective */: {\n                nodeData = nodes[i];\n                if (!nodeData) {\n                    var instance = createDirectiveInstance(view, nodeDef);\n                    nodeData = { instance: instance };\n                }\n                if (nodeDef.flags & 32768 /* Component */) {\n                    var compView = asElementData(view, nodeDef.parent.nodeIndex).componentView;\n                    initView(compView, nodeData.instance, nodeData.instance);\n                }\n                break;\n            }\n            case 32 /* TypePureArray */:\n            case 64 /* TypePureObject */:\n            case 128 /* TypePurePipe */:\n                nodeData = createPureExpression(view, nodeDef);\n                break;\n            case 67108864 /* TypeContentQuery */:\n            case 134217728 /* TypeViewQuery */:\n                nodeData = createQuery();\n                break;\n            case 8 /* 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    // fill static content and view queries\n    execQueriesAction(view, 67108864 /* TypeContentQuery */ | 134217728 /* TypeViewQuery */, 268435456 /* StaticQuery */, 0 /* CheckAndUpdate */);\n}\nfunction checkNoChangesView(view) {\n    markProjectedViewsForCheck(view);\n    Services.updateDirectives(view, 1 /* CheckNoChanges */);\n    execEmbeddedViewsAction(view, ViewAction.CheckNoChanges);\n    Services.updateRenderer(view, 1 /* 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 &= ~(64 /* CheckProjectedViews */ | 32 /* CheckProjectedView */);\n}\nfunction checkAndUpdateView(view) {\n    if (view.state & 1 /* BeforeFirstCheck */) {\n        view.state &= ~1 /* BeforeFirstCheck */;\n        view.state |= 2 /* FirstCheck */;\n    }\n    else {\n        view.state &= ~2 /* FirstCheck */;\n    }\n    shiftInitState(view, 0 /* InitState_BeforeInit */, 256 /* InitState_CallingOnInit */);\n    markProjectedViewsForCheck(view);\n    Services.updateDirectives(view, 0 /* CheckAndUpdate */);\n    execEmbeddedViewsAction(view, ViewAction.CheckAndUpdate);\n    execQueriesAction(view, 67108864 /* TypeContentQuery */, 536870912 /* DynamicQuery */, 0 /* CheckAndUpdate */);\n    var callInit = shiftInitState(view, 256 /* InitState_CallingOnInit */, 512 /* InitState_CallingAfterContentInit */);\n    callLifecycleHooksChildrenFirst(view, 2097152 /* AfterContentChecked */ | (callInit ? 1048576 /* AfterContentInit */ : 0));\n    Services.updateRenderer(view, 0 /* CheckAndUpdate */);\n    execComponentViewsAction(view, ViewAction.CheckAndUpdate);\n    execQueriesAction(view, 134217728 /* TypeViewQuery */, 536870912 /* DynamicQuery */, 0 /* CheckAndUpdate */);\n    callInit = shiftInitState(view, 512 /* InitState_CallingAfterContentInit */, 768 /* InitState_CallingAfterViewInit */);\n    callLifecycleHooksChildrenFirst(view, 8388608 /* AfterViewChecked */ | (callInit ? 4194304 /* AfterViewInit */ : 0));\n    if (view.def.flags & 2 /* OnPush */) {\n        view.state &= ~8 /* ChecksEnabled */;\n    }\n    view.state &= ~(64 /* CheckProjectedViews */ | 32 /* CheckProjectedView */);\n    shiftInitState(view, 768 /* InitState_CallingAfterViewInit */, 1024 /* InitState_AfterInit */);\n}\nfunction checkAndUpdateNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    if (argStyle === 0 /* Inline */) {\n        return checkAndUpdateNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    }\n    else {\n        return checkAndUpdateNodeDynamic(view, nodeDef, v0);\n    }\n}\nfunction markProjectedViewsForCheck(view) {\n    var def = view.def;\n    if (!(def.nodeFlags & 4 /* ProjectedTemplate */)) {\n        return;\n    }\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        if (nodeDef.flags & 4 /* ProjectedTemplate */) {\n            var projectedViews = asElementData(view, i).template._projectedViews;\n            if (projectedViews) {\n                for (var i_1 = 0; i_1 < projectedViews.length; i_1++) {\n                    var projectedView = projectedViews[i_1];\n                    projectedView.state |= 32 /* CheckProjectedView */;\n                    markParentViewsForCheckProjectedViews(projectedView, view);\n                }\n            }\n        }\n        else if ((nodeDef.childFlags & 4 /* 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}\nfunction checkAndUpdateNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    switch (nodeDef.flags & 201347067 /* Types */) {\n        case 1 /* TypeElement */:\n            return checkAndUpdateElementInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        case 2 /* TypeText */:\n            return checkAndUpdateTextInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        case 16384 /* TypeDirective */:\n            return checkAndUpdateDirectiveInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        case 32 /* TypePureArray */:\n        case 64 /* TypePureObject */:\n        case 128 /* TypePurePipe */:\n            return checkAndUpdatePureExpressionInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        default:\n            throw 'unreachable';\n    }\n}\nfunction checkAndUpdateNodeDynamic(view, nodeDef, values) {\n    switch (nodeDef.flags & 201347067 /* Types */) {\n        case 1 /* TypeElement */:\n            return checkAndUpdateElementDynamic(view, nodeDef, values);\n        case 2 /* TypeText */:\n            return checkAndUpdateTextDynamic(view, nodeDef, values);\n        case 16384 /* TypeDirective */:\n            return checkAndUpdateDirectiveDynamic(view, nodeDef, values);\n        case 32 /* TypePureArray */:\n        case 64 /* TypePureObject */:\n        case 128 /* TypePurePipe */:\n            return checkAndUpdatePureExpressionDynamic(view, nodeDef, values);\n        default:\n            throw 'unreachable';\n    }\n}\nfunction checkNoChangesNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    if (argStyle === 0 /* Inline */) {\n        checkNoChangesNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    }\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}\nfunction checkNoChangesNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var bindLen = nodeDef.bindings.length;\n    if (bindLen > 0)\n        checkBindingNoChanges(view, nodeDef, 0, v0);\n    if (bindLen > 1)\n        checkBindingNoChanges(view, nodeDef, 1, v1);\n    if (bindLen > 2)\n        checkBindingNoChanges(view, nodeDef, 2, v2);\n    if (bindLen > 3)\n        checkBindingNoChanges(view, nodeDef, 3, v3);\n    if (bindLen > 4)\n        checkBindingNoChanges(view, nodeDef, 4, v4);\n    if (bindLen > 5)\n        checkBindingNoChanges(view, nodeDef, 5, v5);\n    if (bindLen > 6)\n        checkBindingNoChanges(view, nodeDef, 6, v6);\n    if (bindLen > 7)\n        checkBindingNoChanges(view, nodeDef, 7, v7);\n    if (bindLen > 8)\n        checkBindingNoChanges(view, nodeDef, 8, v8);\n    if (bindLen > 9)\n        checkBindingNoChanges(view, nodeDef, 9, v9);\n}\nfunction checkNoChangesNodeDynamic(view, nodeDef, values) {\n    for (var i = 0; i < values.length; i++) {\n        checkBindingNoChanges(view, nodeDef, i, values[i]);\n    }\n}\n/**\n * Workaround https://github.com/angular/tsickle/issues/497\n * @suppress {misplacedTypeAnnotation}\n */\nfunction checkNoChangesQuery(view, nodeDef) {\n    var queryList = asQueryList(view, nodeDef.nodeIndex);\n    if (queryList.dirty) {\n        throw expressionChangedAfterItHasBeenCheckedError(Services.createDebugContext(view, nodeDef.nodeIndex), \"Query \" + nodeDef.query.id + \" not dirty\", \"Query \" + nodeDef.query.id + \" dirty\", (view.state & 1 /* BeforeFirstCheck */) !== 0);\n    }\n}\nfunction destroyView(view) {\n    if (view.state & 128 /* Destroyed */) {\n        return;\n    }\n    execEmbeddedViewsAction(view, ViewAction.Destroy);\n    execComponentViewsAction(view, ViewAction.Destroy);\n    callLifecycleHooksChildrenFirst(view, 131072 /* OnDestroy */);\n    if (view.disposables) {\n        for (var 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 |= 128 /* Destroyed */;\n}\nfunction destroyViewNodes(view) {\n    var len = view.def.nodes.length;\n    for (var i = 0; i < len; i++) {\n        var def = view.def.nodes[i];\n        if (def.flags & 1 /* TypeElement */) {\n            view.renderer.destroyNode(asElementData(view, i).renderElement);\n        }\n        else if (def.flags & 2 /* TypeText */) {\n            view.renderer.destroyNode(asTextData(view, i).renderText);\n        }\n        else if (def.flags & 67108864 /* TypeContentQuery */ || def.flags & 134217728 /* TypeViewQuery */) {\n            asQueryList(view, i).destroy();\n        }\n    }\n}\nvar ViewAction;\n(function (ViewAction) {\n    ViewAction[ViewAction[\"CreateViewNodes\"] = 0] = \"CreateViewNodes\";\n    ViewAction[ViewAction[\"CheckNoChanges\"] = 1] = \"CheckNoChanges\";\n    ViewAction[ViewAction[\"CheckNoChangesProjectedViews\"] = 2] = \"CheckNoChangesProjectedViews\";\n    ViewAction[ViewAction[\"CheckAndUpdate\"] = 3] = \"CheckAndUpdate\";\n    ViewAction[ViewAction[\"CheckAndUpdateProjectedViews\"] = 4] = \"CheckAndUpdateProjectedViews\";\n    ViewAction[ViewAction[\"Destroy\"] = 5] = \"Destroy\";\n})(ViewAction || (ViewAction = {}));\nfunction execComponentViewsAction(view, action) {\n    var def = view.def;\n    if (!(def.nodeFlags & 33554432 /* ComponentView */)) {\n        return;\n    }\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        if (nodeDef.flags & 33554432 /* ComponentView */) {\n            // a leaf\n            callViewAction(asElementData(view, i).componentView, action);\n        }\n        else if ((nodeDef.childFlags & 33554432 /* 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}\nfunction execEmbeddedViewsAction(view, action) {\n    var def = view.def;\n    if (!(def.nodeFlags & 16777216 /* EmbeddedViews */)) {\n        return;\n    }\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n            // a leaf\n            var embeddedViews = asElementData(view, i).viewContainer._embeddedViews;\n            for (var k = 0; k < embeddedViews.length; k++) {\n                callViewAction(embeddedViews[k], action);\n            }\n        }\n        else if ((nodeDef.childFlags & 16777216 /* 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}\nfunction callViewAction(view, action) {\n    var viewState = view.state;\n    switch (action) {\n        case ViewAction.CheckNoChanges:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if ((viewState & 12 /* CatDetectChanges */) === 12 /* CatDetectChanges */) {\n                    checkNoChangesView(view);\n                }\n                else if (viewState & 64 /* CheckProjectedViews */) {\n                    execProjectedViewsAction(view, ViewAction.CheckNoChangesProjectedViews);\n                }\n            }\n            break;\n        case ViewAction.CheckNoChangesProjectedViews:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if (viewState & 32 /* CheckProjectedView */) {\n                    checkNoChangesView(view);\n                }\n                else if (viewState & 64 /* CheckProjectedViews */) {\n                    execProjectedViewsAction(view, action);\n                }\n            }\n            break;\n        case ViewAction.CheckAndUpdate:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if ((viewState & 12 /* CatDetectChanges */) === 12 /* CatDetectChanges */) {\n                    checkAndUpdateView(view);\n                }\n                else if (viewState & 64 /* CheckProjectedViews */) {\n                    execProjectedViewsAction(view, ViewAction.CheckAndUpdateProjectedViews);\n                }\n            }\n            break;\n        case ViewAction.CheckAndUpdateProjectedViews:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if (viewState & 32 /* CheckProjectedView */) {\n                    checkAndUpdateView(view);\n                }\n                else if (viewState & 64 /* 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}\nfunction execProjectedViewsAction(view, action) {\n    execEmbeddedViewsAction(view, action);\n    execComponentViewsAction(view, action);\n}\nfunction execQueriesAction(view, queryFlags, staticDynamicQueryFlag, checkType) {\n    if (!(view.def.nodeFlags & queryFlags) || !(view.def.nodeFlags & staticDynamicQueryFlag)) {\n        return;\n    }\n    var nodeCount = view.def.nodes.length;\n    for (var i = 0; i < nodeCount; i++) {\n        var nodeDef = view.def.nodes[i];\n        if ((nodeDef.flags & queryFlags) && (nodeDef.flags & staticDynamicQueryFlag)) {\n            Services.setCurrentNode(view, nodeDef.nodeIndex);\n            switch (checkType) {\n                case 0 /* CheckAndUpdate */:\n                    checkAndUpdateQuery(view, nodeDef);\n                    break;\n                case 1 /* 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/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar initialized = false;\nfunction initServicesIfNeeded() {\n    if (initialized) {\n        return;\n    }\n    initialized = true;\n    var 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.overrideComponentView = services.overrideComponentView;\n    Services.clearOverrides = services.clearOverrides;\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}\nfunction createProdServices() {\n    return {\n        setCurrentNode: function () { },\n        createRootView: createProdRootView,\n        createEmbeddedView: createEmbeddedView,\n        createComponentView: createComponentView,\n        createNgModuleRef: createNgModuleRef,\n        overrideProvider: NOOP,\n        overrideComponentView: NOOP,\n        clearOverrides: NOOP,\n        checkAndUpdateView: checkAndUpdateView,\n        checkNoChangesView: checkNoChangesView,\n        destroyView: destroyView,\n        createDebugContext: function (view, nodeIndex) { return new DebugContext_(view, nodeIndex); },\n        handleEvent: function (view, nodeIndex, eventName, event) {\n            return view.def.handleEvent(view, nodeIndex, eventName, event);\n        },\n        updateDirectives: function (view, checkType) {\n            return view.def.updateDirectives(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :\n                prodCheckNoChangesNode, view);\n        },\n        updateRenderer: function (view, checkType) {\n            return view.def.updateRenderer(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :\n                prodCheckNoChangesNode, view);\n        },\n    };\n}\nfunction createDebugServices() {\n    return {\n        setCurrentNode: debugSetCurrentNode,\n        createRootView: debugCreateRootView,\n        createEmbeddedView: debugCreateEmbeddedView,\n        createComponentView: debugCreateComponentView,\n        createNgModuleRef: debugCreateNgModuleRef,\n        overrideProvider: debugOverrideProvider,\n        overrideComponentView: debugOverrideComponentView,\n        clearOverrides: debugClearOverrides,\n        checkAndUpdateView: debugCheckAndUpdateView,\n        checkNoChangesView: debugCheckNoChangesView,\n        destroyView: debugDestroyView,\n        createDebugContext: function (view, nodeIndex) { return new DebugContext_(view, nodeIndex); },\n        handleEvent: debugHandleEvent,\n        updateDirectives: debugUpdateDirectives,\n        updateRenderer: debugUpdateRenderer,\n    };\n}\nfunction createProdRootView(elInjector, projectableNodes, rootSelectorOrNode, def, ngModule, context) {\n    var rendererFactory = ngModule.injector.get(RendererFactory2);\n    return createRootView(createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode), def, context);\n}\nfunction debugCreateRootView(elInjector, projectableNodes, rootSelectorOrNode, def, ngModule, context) {\n    var rendererFactory = ngModule.injector.get(RendererFactory2);\n    var root = createRootData(elInjector, ngModule, new DebugRendererFactory2(rendererFactory), projectableNodes, rootSelectorOrNode);\n    var defWithOverride = applyProviderOverridesToView(def);\n    return callWithDebugContext(DebugAction.create, createRootView, null, [root, defWithOverride, context]);\n}\nfunction createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode) {\n    var sanitizer = ngModule.injector.get(Sanitizer);\n    var errorHandler = ngModule.injector.get(ErrorHandler);\n    var renderer = rendererFactory.createRenderer(null, null);\n    return {\n        ngModule: ngModule,\n        injector: elInjector, projectableNodes: projectableNodes,\n        selectorOrNode: rootSelectorOrNode, sanitizer: sanitizer, rendererFactory: rendererFactory, renderer: renderer, errorHandler: errorHandler\n    };\n}\nfunction debugCreateEmbeddedView(parentView, anchorDef, viewDef$$1, context) {\n    var defWithOverride = applyProviderOverridesToView(viewDef$$1);\n    return callWithDebugContext(DebugAction.create, createEmbeddedView, null, [parentView, anchorDef, defWithOverride, context]);\n}\nfunction debugCreateComponentView(parentView, nodeDef, viewDef$$1, hostElement) {\n    var overrideComponentView = viewDefOverrides.get(nodeDef.element.componentProvider.provider.token);\n    if (overrideComponentView) {\n        viewDef$$1 = overrideComponentView;\n    }\n    else {\n        viewDef$$1 = applyProviderOverridesToView(viewDef$$1);\n    }\n    return callWithDebugContext(DebugAction.create, createComponentView, null, [parentView, nodeDef, viewDef$$1, hostElement]);\n}\nfunction debugCreateNgModuleRef(moduleType, parentInjector, bootstrapComponents, def) {\n    var defWithOverride = applyProviderOverridesToNgModule(def);\n    return createNgModuleRef(moduleType, parentInjector, bootstrapComponents, defWithOverride);\n}\nvar providerOverrides = new Map();\nvar providerOverridesWithScope = new Map();\nvar viewDefOverrides = new Map();\nfunction debugOverrideProvider(override) {\n    providerOverrides.set(override.token, override);\n    if (typeof override.token === 'function' && override.token.ngInjectableDef &&\n        typeof override.token.ngInjectableDef.providedIn === 'function') {\n        providerOverridesWithScope.set(override.token, override);\n    }\n}\nfunction debugOverrideComponentView(comp, compFactory) {\n    var hostViewDef = resolveDefinition(getComponentViewDefinitionFactory(compFactory));\n    var compViewDef = resolveDefinition((hostViewDef.nodes[0].element.componentView));\n    viewDefOverrides.set(comp, compViewDef);\n}\nfunction debugClearOverrides() {\n    providerOverrides.clear();\n    providerOverridesWithScope.clear();\n    viewDefOverrides.clear();\n}\n// Notes about the algorithm:\n// 1) Locate the providers of an element and check if one of them was overwritten\n// 2) Change the providers of that element\n//\n// We only create new datastructures if we need to, to keep perf impact\n// reasonable.\nfunction applyProviderOverridesToView(def) {\n    if (providerOverrides.size === 0) {\n        return def;\n    }\n    var 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 = def.factory(function () { return NOOP; });\n    for (var i = 0; i < elementIndicesWithOverwrittenProviders.length; i++) {\n        applyProviderOverridesToElement(def, elementIndicesWithOverwrittenProviders[i]);\n    }\n    return def;\n    function findElementIndicesWithOverwrittenProviders(def) {\n        var elIndicesWithOverwrittenProviders = [];\n        var lastElementDef = null;\n        for (var i = 0; i < def.nodes.length; i++) {\n            var nodeDef = def.nodes[i];\n            if (nodeDef.flags & 1 /* TypeElement */) {\n                lastElementDef = nodeDef;\n            }\n            if (lastElementDef && nodeDef.flags & 3840 /* CatProviderNoDirective */ &&\n                providerOverrides.has(nodeDef.provider.token)) {\n                elIndicesWithOverwrittenProviders.push(lastElementDef.nodeIndex);\n                lastElementDef = null;\n            }\n        }\n        return elIndicesWithOverwrittenProviders;\n    }\n    function applyProviderOverridesToElement(viewDef$$1, elIndex) {\n        for (var i = elIndex + 1; i < viewDef$$1.nodes.length; i++) {\n            var nodeDef = viewDef$$1.nodes[i];\n            if (nodeDef.flags & 1 /* TypeElement */) {\n                // stop at the next element\n                return;\n            }\n            if (nodeDef.flags & 3840 /* CatProviderNoDirective */) {\n                var provider = (nodeDef.provider);\n                var override = providerOverrides.get(provider.token);\n                if (override) {\n                    nodeDef.flags = (nodeDef.flags & ~3840 /* CatProviderNoDirective */) | override.flags;\n                    provider.deps = splitDepsDsl(override.deps);\n                    provider.value = override.value;\n                }\n            }\n        }\n    }\n}\n// Notes about the algorithm:\n// We only create new datastructures if we need to, to keep perf impact\n// reasonable.\nfunction applyProviderOverridesToNgModule(def) {\n    var _a = calcHasOverrides(def), hasOverrides = _a.hasOverrides, hasDeprecatedOverrides = _a.hasDeprecatedOverrides;\n    if (!hasOverrides) {\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 = def.factory(function () { return NOOP; });\n    applyProviderOverrides(def);\n    return def;\n    function calcHasOverrides(def) {\n        var hasOverrides = false;\n        var hasDeprecatedOverrides = false;\n        if (providerOverrides.size === 0) {\n            return { hasOverrides: hasOverrides, hasDeprecatedOverrides: hasDeprecatedOverrides };\n        }\n        def.providers.forEach(function (node) {\n            var override = providerOverrides.get(node.token);\n            if ((node.flags & 3840 /* CatProviderNoDirective */) && override) {\n                hasOverrides = true;\n                hasDeprecatedOverrides = hasDeprecatedOverrides || override.deprecatedBehavior;\n            }\n        });\n        def.modules.forEach(function (module) {\n            providerOverridesWithScope.forEach(function (override, token) {\n                if (token.ngInjectableDef.providedIn === module) {\n                    hasOverrides = true;\n                    hasDeprecatedOverrides = hasDeprecatedOverrides || override.deprecatedBehavior;\n                }\n            });\n        });\n        return { hasOverrides: hasOverrides, hasDeprecatedOverrides: hasDeprecatedOverrides };\n    }\n    function applyProviderOverrides(def) {\n        for (var i = 0; i < def.providers.length; i++) {\n            var provider = def.providers[i];\n            if (hasDeprecatedOverrides) {\n                // We had a bug where me made\n                // all providers lazy. Keep this logic behind a flag\n                // for migrating existing users.\n                provider.flags |= 4096 /* LazyProvider */;\n            }\n            var override = providerOverrides.get(provider.token);\n            if (override) {\n                provider.flags = (provider.flags & ~3840 /* CatProviderNoDirective */) | override.flags;\n                provider.deps = splitDepsDsl(override.deps);\n                provider.value = override.value;\n            }\n        }\n        if (providerOverridesWithScope.size > 0) {\n            var moduleSet_1 = new Set(def.modules);\n            providerOverridesWithScope.forEach(function (override, token) {\n                if (moduleSet_1.has(token.ngInjectableDef.providedIn)) {\n                    var provider = {\n                        token: token,\n                        flags: override.flags | (hasDeprecatedOverrides ? 4096 /* LazyProvider */ : 0 /* None */),\n                        deps: splitDepsDsl(override.deps),\n                        value: override.value,\n                        index: def.providers.length,\n                    };\n                    def.providers.push(provider);\n                    def.providersByKey[tokenKey(token)] = provider;\n                }\n            });\n        }\n    }\n}\nfunction prodCheckAndUpdateNode(view, checkIndex, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var nodeDef = view.def.nodes[checkIndex];\n    checkAndUpdateNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    return (nodeDef.flags & 224 /* CatPureExpression */) ?\n        asPureExpressionData(view, checkIndex).value :\n        undefined;\n}\nfunction prodCheckNoChangesNode(view, checkIndex, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var nodeDef = view.def.nodes[checkIndex];\n    checkNoChangesNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    return (nodeDef.flags & 224 /* CatPureExpression */) ?\n        asPureExpressionData(view, checkIndex).value :\n        undefined;\n}\nfunction debugCheckAndUpdateView(view) {\n    return callWithDebugContext(DebugAction.detectChanges, checkAndUpdateView, null, [view]);\n}\nfunction debugCheckNoChangesView(view) {\n    return callWithDebugContext(DebugAction.checkNoChanges, checkNoChangesView, null, [view]);\n}\nfunction debugDestroyView(view) {\n    return callWithDebugContext(DebugAction.destroy, destroyView, null, [view]);\n}\nvar DebugAction;\n(function (DebugAction) {\n    DebugAction[DebugAction[\"create\"] = 0] = \"create\";\n    DebugAction[DebugAction[\"detectChanges\"] = 1] = \"detectChanges\";\n    DebugAction[DebugAction[\"checkNoChanges\"] = 2] = \"checkNoChanges\";\n    DebugAction[DebugAction[\"destroy\"] = 3] = \"destroy\";\n    DebugAction[DebugAction[\"handleEvent\"] = 4] = \"handleEvent\";\n})(DebugAction || (DebugAction = {}));\nvar _currentAction;\nvar _currentView;\nvar _currentNodeIndex;\nfunction debugSetCurrentNode(view, nodeIndex) {\n    _currentView = view;\n    _currentNodeIndex = nodeIndex;\n}\nfunction debugHandleEvent(view, nodeIndex, eventName, event) {\n    debugSetCurrentNode(view, nodeIndex);\n    return callWithDebugContext(DebugAction.handleEvent, view.def.handleEvent, null, [view, nodeIndex, eventName, event]);\n}\nfunction debugUpdateDirectives(view, checkType) {\n    if (view.state & 128 /* Destroyed */) {\n        throw viewDestroyedError(DebugAction[_currentAction]);\n    }\n    debugSetCurrentNode(view, nextDirectiveWithBinding(view, 0));\n    return view.def.updateDirectives(debugCheckDirectivesFn, view);\n    function debugCheckDirectivesFn(view, nodeIndex, argStyle) {\n        var values = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            values[_i - 3] = arguments[_i];\n        }\n        var nodeDef = view.def.nodes[nodeIndex];\n        if (checkType === 0 /* CheckAndUpdate */) {\n            debugCheckAndUpdateNode(view, nodeDef, argStyle, values);\n        }\n        else {\n            debugCheckNoChangesNode(view, nodeDef, argStyle, values);\n        }\n        if (nodeDef.flags & 16384 /* TypeDirective */) {\n            debugSetCurrentNode(view, nextDirectiveWithBinding(view, nodeIndex));\n        }\n        return (nodeDef.flags & 224 /* CatPureExpression */) ?\n            asPureExpressionData(view, nodeDef.nodeIndex).value :\n            undefined;\n    }\n}\nfunction debugUpdateRenderer(view, checkType) {\n    if (view.state & 128 /* Destroyed */) {\n        throw viewDestroyedError(DebugAction[_currentAction]);\n    }\n    debugSetCurrentNode(view, nextRenderNodeWithBinding(view, 0));\n    return view.def.updateRenderer(debugCheckRenderNodeFn, view);\n    function debugCheckRenderNodeFn(view, nodeIndex, argStyle) {\n        var values = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            values[_i - 3] = arguments[_i];\n        }\n        var nodeDef = view.def.nodes[nodeIndex];\n        if (checkType === 0 /* CheckAndUpdate */) {\n            debugCheckAndUpdateNode(view, nodeDef, argStyle, values);\n        }\n        else {\n            debugCheckNoChangesNode(view, nodeDef, argStyle, values);\n        }\n        if (nodeDef.flags & 3 /* CatRenderNode */) {\n            debugSetCurrentNode(view, nextRenderNodeWithBinding(view, nodeIndex));\n        }\n        return (nodeDef.flags & 224 /* CatPureExpression */) ?\n            asPureExpressionData(view, nodeDef.nodeIndex).value :\n            undefined;\n    }\n}\nfunction debugCheckAndUpdateNode(view, nodeDef, argStyle, givenValues) {\n    var changed = checkAndUpdateNode.apply(void 0, __spread([view, nodeDef, argStyle], givenValues));\n    if (changed) {\n        var values = argStyle === 1 /* Dynamic */ ? givenValues[0] : givenValues;\n        if (nodeDef.flags & 16384 /* TypeDirective */) {\n            var bindingValues = {};\n            for (var i = 0; i < nodeDef.bindings.length; i++) {\n                var binding = nodeDef.bindings[i];\n                var value = values[i];\n                if (binding.flags & 8 /* TypeProperty */) {\n                    bindingValues[normalizeDebugBindingName((binding.nonMinifiedName))] =\n                        normalizeDebugBindingValue(value);\n                }\n            }\n            var elDef = (nodeDef.parent);\n            var el = asElementData(view, elDef.nodeIndex).renderElement;\n            if (!elDef.element.name) {\n                // a comment.\n                view.renderer.setValue(el, \"bindings=\" + JSON.stringify(bindingValues, null, 2));\n            }\n            else {\n                // a regular element.\n                for (var attr in bindingValues) {\n                    var value = bindingValues[attr];\n                    if (value != null) {\n                        view.renderer.setAttribute(el, attr, value);\n                    }\n                    else {\n                        view.renderer.removeAttribute(el, attr);\n                    }\n                }\n            }\n        }\n    }\n}\nfunction debugCheckNoChangesNode(view, nodeDef, argStyle, values) {\n    checkNoChangesNode.apply(void 0, __spread([view, nodeDef, argStyle], values));\n}\nfunction normalizeDebugBindingName(name) {\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}\nvar CAMEL_CASE_REGEXP = /([A-Z])/g;\nfunction camelCaseToDashCase(input) {\n    return input.replace(CAMEL_CASE_REGEXP, function () {\n        var m = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            m[_i] = arguments[_i];\n        }\n        return '-' + m[1].toLowerCase();\n    });\n}\nfunction normalizeDebugBindingValue(value) {\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    }\n    catch (e) {\n        return '[ERROR] Exception while trying to serialize the value';\n    }\n}\nfunction nextDirectiveWithBinding(view, nodeIndex) {\n    for (var i = nodeIndex; i < view.def.nodes.length; i++) {\n        var nodeDef = view.def.nodes[i];\n        if (nodeDef.flags & 16384 /* TypeDirective */ && nodeDef.bindings && nodeDef.bindings.length) {\n            return i;\n        }\n    }\n    return null;\n}\nfunction nextRenderNodeWithBinding(view, nodeIndex) {\n    for (var i = nodeIndex; i < view.def.nodes.length; i++) {\n        var nodeDef = view.def.nodes[i];\n        if ((nodeDef.flags & 3 /* CatRenderNode */) && nodeDef.bindings && nodeDef.bindings.length) {\n            return i;\n        }\n    }\n    return null;\n}\nvar DebugContext_ = /** @class */ (function () {\n    function DebugContext_(view, nodeIndex) {\n        this.view = view;\n        this.nodeIndex = nodeIndex;\n        if (nodeIndex == null) {\n            this.nodeIndex = nodeIndex = 0;\n        }\n        this.nodeDef = view.def.nodes[nodeIndex];\n        var elDef = this.nodeDef;\n        var elView = view;\n        while (elDef && (elDef.flags & 1 /* 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    Object.defineProperty(DebugContext_.prototype, \"elOrCompView\", {\n        get: function () {\n            // Has to be done lazily as we use the DebugContext also during creation of elements...\n            return asElementData(this.elView, this.elDef.nodeIndex).componentView || this.view;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"injector\", {\n        get: function () { return createInjector$1(this.elView, this.elDef); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"component\", {\n        get: function () { return this.elOrCompView.component; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"context\", {\n        get: function () { return this.elOrCompView.context; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"providerTokens\", {\n        get: function () {\n            var tokens = [];\n            if (this.elDef) {\n                for (var i = this.elDef.nodeIndex + 1; i <= this.elDef.nodeIndex + this.elDef.childCount; i++) {\n                    var childDef = this.elView.def.nodes[i];\n                    if (childDef.flags & 20224 /* CatProvider */) {\n                        tokens.push(childDef.provider.token);\n                    }\n                    i += childDef.childCount;\n                }\n            }\n            return tokens;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"references\", {\n        get: function () {\n            var references = {};\n            if (this.elDef) {\n                collectReferences(this.elView, this.elDef, references);\n                for (var i = this.elDef.nodeIndex + 1; i <= this.elDef.nodeIndex + this.elDef.childCount; i++) {\n                    var childDef = this.elView.def.nodes[i];\n                    if (childDef.flags & 20224 /* CatProvider */) {\n                        collectReferences(this.elView, childDef, references);\n                    }\n                    i += childDef.childCount;\n                }\n            }\n            return references;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"componentRenderElement\", {\n        get: function () {\n            var elData = findHostElement(this.elOrCompView);\n            return elData ? elData.renderElement : undefined;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"renderNode\", {\n        get: function () {\n            return this.nodeDef.flags & 2 /* TypeText */ ? renderNode(this.view, this.nodeDef) :\n                renderNode(this.elView, this.elDef);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DebugContext_.prototype.logError = function (console) {\n        var values = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            values[_i - 1] = arguments[_i];\n        }\n        var logViewDef;\n        var logNodeIndex;\n        if (this.nodeDef.flags & 2 /* TypeText */) {\n            logViewDef = this.view.def;\n            logNodeIndex = this.nodeDef.nodeIndex;\n        }\n        else {\n            logViewDef = this.elView.def;\n            logNodeIndex = this.elDef.nodeIndex;\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        var renderNodeIndex = getRenderNodeIndex(logViewDef, logNodeIndex);\n        var currRenderNodeIndex = -1;\n        var nodeLogger = function () {\n            currRenderNodeIndex++;\n            if (currRenderNodeIndex === renderNodeIndex) {\n                return (_a = console.error).bind.apply(_a, __spread([console], values));\n            }\n            else {\n                return NOOP;\n            }\n            var _a;\n        };\n        logViewDef.factory(nodeLogger);\n        if (currRenderNodeIndex < renderNodeIndex) {\n            console.error('Illegal state: the ViewDefinitionFactory did not call the logger!');\n            console.error.apply(console, __spread(values));\n        }\n    };\n    return DebugContext_;\n}());\nfunction getRenderNodeIndex(viewDef$$1, nodeIndex) {\n    var renderNodeIndex = -1;\n    for (var i = 0; i <= nodeIndex; i++) {\n        var nodeDef = viewDef$$1.nodes[i];\n        if (nodeDef.flags & 3 /* CatRenderNode */) {\n            renderNodeIndex++;\n        }\n    }\n    return renderNodeIndex;\n}\nfunction findHostElement(view) {\n    while (view && !isComponentView(view)) {\n        view = (view.parent);\n    }\n    if (view.parent) {\n        return asElementData(view.parent, viewParentEl(view).nodeIndex);\n    }\n    return null;\n}\nfunction collectReferences(view, nodeDef, references) {\n    for (var refName in nodeDef.references) {\n        references[refName] = getQueryValue(view, nodeDef, nodeDef.references[refName]);\n    }\n}\nfunction callWithDebugContext(action, fn, self, args) {\n    var oldAction = _currentAction;\n    var oldView = _currentView;\n    var oldNodeIndex = _currentNodeIndex;\n    try {\n        _currentAction = action;\n        var result = fn.apply(self, args);\n        _currentView = oldView;\n        _currentNodeIndex = oldNodeIndex;\n        _currentAction = oldAction;\n        return result;\n    }\n    catch (e) {\n        if (isViewDebugError(e) || !_currentView) {\n            throw e;\n        }\n        throw viewWrappedDebugError(e, (getCurrentDebugContext()));\n    }\n}\nfunction getCurrentDebugContext() {\n    return _currentView ? new DebugContext_(_currentView, _currentNodeIndex) : null;\n}\nvar DebugRendererFactory2 = /** @class */ (function () {\n    function DebugRendererFactory2(delegate) {\n        this.delegate = delegate;\n    }\n    DebugRendererFactory2.prototype.createRenderer = function (element, renderData) {\n        return new DebugRenderer2(this.delegate.createRenderer(element, renderData));\n    };\n    DebugRendererFactory2.prototype.begin = function () {\n        if (this.delegate.begin) {\n            this.delegate.begin();\n        }\n    };\n    DebugRendererFactory2.prototype.end = function () {\n        if (this.delegate.end) {\n            this.delegate.end();\n        }\n    };\n    DebugRendererFactory2.prototype.whenRenderingDone = function () {\n        if (this.delegate.whenRenderingDone) {\n            return this.delegate.whenRenderingDone();\n        }\n        return Promise.resolve(null);\n    };\n    return DebugRendererFactory2;\n}());\nvar DebugRenderer2 = /** @class */ (function () {\n    function DebugRenderer2(delegate) {\n        this.delegate = delegate;\n        this.data = this.delegate.data;\n    }\n    DebugRenderer2.prototype.destroyNode = function (node) {\n        removeDebugNodeFromIndex((getDebugNode(node)));\n        if (this.delegate.destroyNode) {\n            this.delegate.destroyNode(node);\n        }\n    };\n    DebugRenderer2.prototype.destroy = function () { this.delegate.destroy(); };\n    DebugRenderer2.prototype.createElement = function (name, namespace) {\n        var el = this.delegate.createElement(name, namespace);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            var debugEl = new DebugElement(el, null, debugCtx);\n            debugEl.name = name;\n            indexDebugNode(debugEl);\n        }\n        return el;\n    };\n    DebugRenderer2.prototype.createComment = function (value) {\n        var comment = this.delegate.createComment(value);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            indexDebugNode(new DebugNode(comment, null, debugCtx));\n        }\n        return comment;\n    };\n    DebugRenderer2.prototype.createText = function (value) {\n        var text = this.delegate.createText(value);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            indexDebugNode(new DebugNode(text, null, debugCtx));\n        }\n        return text;\n    };\n    DebugRenderer2.prototype.appendChild = function (parent, newChild) {\n        var debugEl = getDebugNode(parent);\n        var debugChildEl = getDebugNode(newChild);\n        if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n            debugEl.addChild(debugChildEl);\n        }\n        this.delegate.appendChild(parent, newChild);\n    };\n    DebugRenderer2.prototype.insertBefore = function (parent, newChild, refChild) {\n        var debugEl = getDebugNode(parent);\n        var debugChildEl = getDebugNode(newChild);\n        var debugRefEl = (getDebugNode(refChild));\n        if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n            debugEl.insertBefore(debugRefEl, debugChildEl);\n        }\n        this.delegate.insertBefore(parent, newChild, refChild);\n    };\n    DebugRenderer2.prototype.removeChild = function (parent, oldChild) {\n        var debugEl = getDebugNode(parent);\n        var debugChildEl = getDebugNode(oldChild);\n        if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n            debugEl.removeChild(debugChildEl);\n        }\n        this.delegate.removeChild(parent, oldChild);\n    };\n    DebugRenderer2.prototype.selectRootElement = function (selectorOrNode) {\n        var el = this.delegate.selectRootElement(selectorOrNode);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            indexDebugNode(new DebugElement(el, null, debugCtx));\n        }\n        return el;\n    };\n    DebugRenderer2.prototype.setAttribute = function (el, name, value, namespace) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            var fullName = namespace ? namespace + ':' + name : name;\n            debugEl.attributes[fullName] = value;\n        }\n        this.delegate.setAttribute(el, name, value, namespace);\n    };\n    DebugRenderer2.prototype.removeAttribute = function (el, name, namespace) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            var fullName = namespace ? namespace + ':' + name : name;\n            debugEl.attributes[fullName] = null;\n        }\n        this.delegate.removeAttribute(el, name, namespace);\n    };\n    DebugRenderer2.prototype.addClass = function (el, name) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.classes[name] = true;\n        }\n        this.delegate.addClass(el, name);\n    };\n    DebugRenderer2.prototype.removeClass = function (el, name) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.classes[name] = false;\n        }\n        this.delegate.removeClass(el, name);\n    };\n    DebugRenderer2.prototype.setStyle = function (el, style, value, flags) {\n        var 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    DebugRenderer2.prototype.removeStyle = function (el, style, flags) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.styles[style] = null;\n        }\n        this.delegate.removeStyle(el, style, flags);\n    };\n    DebugRenderer2.prototype.setProperty = function (el, name, value) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.properties[name] = value;\n        }\n        this.delegate.setProperty(el, name, value);\n    };\n    DebugRenderer2.prototype.listen = function (target, eventName, callback) {\n        if (typeof target !== 'string') {\n            var debugEl = getDebugNode(target);\n            if (debugEl) {\n                debugEl.listeners.push(new EventListener(eventName, callback));\n            }\n        }\n        return this.delegate.listen(target, eventName, callback);\n    };\n    DebugRenderer2.prototype.parentNode = function (node) { return this.delegate.parentNode(node); };\n    DebugRenderer2.prototype.nextSibling = function (node) { return this.delegate.nextSibling(node); };\n    DebugRenderer2.prototype.setValue = function (node, value) { return this.delegate.setValue(node, value); };\n    return DebugRenderer2;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction overrideProvider(override) {\n    initServicesIfNeeded();\n    return Services.overrideProvider(override);\n}\nfunction overrideComponentView(comp, componentFactory) {\n    initServicesIfNeeded();\n    return Services.overrideComponentView(comp, componentFactory);\n}\nfunction clearOverrides() {\n    initServicesIfNeeded();\n    return Services.clearOverrides();\n}\n// Attention: this function is called as top level function.\n// Putting any logic in here will destroy closure tree shaking!\nfunction createNgModuleFactory(ngModuleType, bootstrapComponents, defFactory) {\n    return new NgModuleFactory_(ngModuleType, bootstrapComponents, defFactory);\n}\nvar NgModuleFactory_ = /** @class */ (function (_super) {\n    __extends(NgModuleFactory_, _super);\n    function NgModuleFactory_(moduleType, _bootstrapComponents, _ngModuleDefFactory) {\n        var _this = \n        // Attention: this ctor is called as top level function.\n        // Putting any logic in here will destroy closure tree shaking!\n        _super.call(this) || this;\n        _this.moduleType = moduleType;\n        _this._bootstrapComponents = _bootstrapComponents;\n        _this._ngModuleDefFactory = _ngModuleDefFactory;\n        return _this;\n    }\n    NgModuleFactory_.prototype.create = function (parentInjector) {\n        initServicesIfNeeded();\n        var def = resolveDefinition(this._ngModuleDefFactory);\n        return Services.createNgModuleRef(this.moduleType, parentInjector || Injector.NULL, this._bootstrapComponents, def);\n    };\n    return NgModuleFactory_;\n}(NgModuleFactory));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// The functions in this file verify that the assumptions we are making\n// about state in an instruction are correct before implementing any logic.\n// They are meant only to be called in dev mode as sanity checks.\n\nfunction assertEqual(actual, expected, msg) {\n    if (actual != expected) {\n        throwError(msg);\n    }\n}\nfunction assertNotEqual(actual, expected, msg) {\n    if (actual == expected) {\n        throwError(msg);\n    }\n}\nfunction assertSame(actual, expected, msg) {\n    if (actual !== expected) {\n        throwError(msg);\n    }\n}\nfunction assertLessThan(actual, expected, msg) {\n    if (actual >= expected) {\n        throwError(msg);\n    }\n}\nfunction assertGreaterThan(actual, expected, msg) {\n    if (actual <= expected) {\n        throwError(msg);\n    }\n}\nfunction assertNull(actual, msg) {\n    if (actual != null) {\n        throwError(msg);\n    }\n}\nfunction assertNotNull(actual, msg) {\n    if (actual == null) {\n        throwError(msg);\n    }\n}\nfunction assertComponentType(actual, msg) {\n    if (msg === void 0) { msg = 'Type passed in is not ComponentType, it does not have \\'ngComponentDef\\' property.'; }\n    if (!actual.ngComponentDef) {\n        throwError(msg);\n    }\n}\nfunction throwError(msg) {\n    debugger; // Left intentionally for better debugger experience.\n    throw new Error(\"ASSERTION ERROR: \" + msg);\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 * If this is the first template pass, any ngOnInit or ngDoCheck hooks will be queued into\n * TView.initHooks during directiveCreate.\n *\n * The directive index and hook type are encoded into one number (1st bit: type, remaining bits:\n * directive index), then saved in the even indices of the initHooks array. The odd indices\n * hold the hook functions themselves.\n *\n * @param index The index of the directive in LView.data\n * @param hooks The static hooks map on the directive def\n * @param tView The current TView\n */\nfunction queueInitHooks(index, onInit, doCheck, tView) {\n    ngDevMode &&\n        assertEqual(tView.firstTemplatePass, true, 'Should only be called on first template pass');\n    if (onInit) {\n        (tView.initHooks || (tView.initHooks = [])).push(index, onInit);\n    }\n    if (doCheck) {\n        (tView.initHooks || (tView.initHooks = [])).push(index, doCheck);\n        (tView.checkHooks || (tView.checkHooks = [])).push(index, doCheck);\n    }\n}\n/**\n * Loops through the directives on a node and queues all their hooks except ngOnInit\n * and ngDoCheck, which are queued separately in directiveCreate.\n */\nfunction queueLifecycleHooks(flags, currentView) {\n    var tView = currentView.tView;\n    if (tView.firstTemplatePass === true) {\n        var start = flags >> 13;\n        var count = flags & 4095;\n        var end = start + count;\n        // It's necessary to loop through the directives at elementEnd() (rather than processing in\n        // directiveCreate) so we can preserve the current hook order. Content, view, and destroy\n        // hooks for projected components and directives must be called *before* their hosts.\n        for (var i = start; i < end; i++) {\n            var def = tView.directives[i];\n            queueContentHooks(def, tView, i);\n            queueViewHooks(def, tView, i);\n            queueDestroyHooks(def, tView, i);\n        }\n    }\n}\n/** Queues afterContentInit and afterContentChecked hooks on TView */\nfunction queueContentHooks(def, tView, i) {\n    if (def.afterContentInit) {\n        (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentInit);\n    }\n    if (def.afterContentChecked) {\n        (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentChecked);\n        (tView.contentCheckHooks || (tView.contentCheckHooks = [])).push(i, def.afterContentChecked);\n    }\n}\n/** Queues afterViewInit and afterViewChecked hooks on TView */\nfunction queueViewHooks(def, tView, i) {\n    if (def.afterViewInit) {\n        (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewInit);\n    }\n    if (def.afterViewChecked) {\n        (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewChecked);\n        (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, def.afterViewChecked);\n    }\n}\n/** Queues onDestroy hooks on TView */\nfunction queueDestroyHooks(def, tView, i) {\n    if (def.onDestroy != null) {\n        (tView.destroyHooks || (tView.destroyHooks = [])).push(i, def.onDestroy);\n    }\n}\n/**\n * Calls onInit and doCheck calls if they haven't already been called.\n *\n * @param currentView The current view\n */\nfunction executeInitHooks(currentView, tView, creationMode) {\n    if (currentView.lifecycleStage === 1 /* Init */) {\n        executeHooks((currentView.directives), tView.initHooks, tView.checkHooks, creationMode);\n        currentView.lifecycleStage = 2 /* AfterInit */;\n    }\n}\n/**\n * Iterates over afterViewInit and afterViewChecked functions and calls them.\n *\n * @param currentView The current view\n */\nfunction executeHooks(data, allHooks, checkHooks, creationMode) {\n    var hooksToCall = creationMode ? allHooks : checkHooks;\n    if (hooksToCall) {\n        callHooks(data, hooksToCall);\n    }\n}\n/**\n * Calls lifecycle hooks with their contexts, skipping init hooks if it's not\n * creation mode.\n *\n * @param currentView The current view\n * @param arr The array in which the hooks are found\n */\nfunction callHooks(data, arr) {\n    for (var i = 0; i < arr.length; i += 2) {\n        arr[i + 1].call(data[arr[i]]);\n    }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nif (typeof ngDevMode == 'undefined') {\n    if (typeof window != 'undefined')\n        window.ngDevMode = true;\n    if (typeof self != 'undefined')\n        self.ngDevMode = true;\n    if (typeof global != 'undefined')\n        global.ngDevMode = true;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NG_PROJECT_AS_ATTR_NAME = 'ngProjectAs';\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction assertNodeType(node, type) {\n    assertNotNull(node, 'should be called with a node');\n    assertEqual(node.type, type, \"should be a \" + typeName(type));\n}\nfunction assertNodeOfPossibleTypes(node) {\n    var types = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        types[_i - 1] = arguments[_i];\n    }\n    assertNotNull(node, 'should be called with a node');\n    var found = types.some(function (type) { return node.type === type; });\n    assertEqual(found, true, \"Should be one of \" + types.map(typeName).join(', '));\n}\nfunction typeName(type) {\n    if (type == 1 /* Projection */)\n        return 'Projection';\n    if (type == 0 /* Container */)\n        return 'Container';\n    if (type == 2 /* View */)\n        return 'View';\n    if (type == 3 /* Element */)\n        return 'Element';\n    return '<unknown>';\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// TODO: cleanup once the code is merged in angular/angular\n// TODO: cleanup once the code is merged in angular/angular\nvar RendererStyleFlags3;\n// TODO: cleanup once the code is merged in angular/angular\n(function (RendererStyleFlags3) {\n    RendererStyleFlags3[RendererStyleFlags3[\"Important\"] = 1] = \"Important\";\n    RendererStyleFlags3[RendererStyleFlags3[\"DashCase\"] = 2] = \"DashCase\";\n})(RendererStyleFlags3 || (RendererStyleFlags3 = {}));\n/** Returns whether the `renderer` is a `ProceduralRenderer3` */\nfunction isProceduralRenderer(renderer) {\n    return !!(renderer.listen);\n}\nvar domRendererFactory3 = {\n    createRenderer: function (hostElement, rendererType) { return document; }\n};\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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* Must use this method for CD (instead of === ) since NaN !== NaN\n*/\nfunction isDifferent(a, b) {\n    // NaN is the only value that is not equal to itself so the first\n    // test checks if both a and b are not NaN\n    return !(a !== a && b !== b) && a !== b;\n}\nfunction stringify$1(value) {\n    if (typeof value == 'function')\n        return value.name || value;\n    if (typeof value == 'string')\n        return value;\n    if (value == null)\n        return '';\n    return '' + value;\n}\n/**\n *  Function that throws a \"not implemented\" error so it's clear certain\n *  behaviors/methods aren't yet ready.\n *\n * @returns Not implemented error\n */\nfunction notImplemented() {\n    return new Error('NotImplemented');\n}\n/**\n * Flattens an array in non-recursive way. Input arrays are not modified.\n */\nfunction flatten$1(list) {\n    var result = [];\n    var i = 0;\n    while (i < list.length) {\n        var item = list[i];\n        if (Array.isArray(item)) {\n            if (item.length > 0) {\n                list = item.concat(list.slice(i + 1));\n                i = 0;\n            }\n            else {\n                i++;\n            }\n        }\n        else {\n            result.push(item);\n            i++;\n        }\n    }\n    return result;\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 * Returns the first RNode following the given LNode in the same parent DOM element.\n *\n * This is needed in order to insert the given node with insertBefore.\n *\n * @param node The node whose following DOM node must be found.\n * @param stopNode A parent node at which the lookup in the tree should be stopped, or null if the\n * lookup should not be stopped until the result is found.\n * @returns RNode before which the provided node should be inserted or null if the lookup was\n * stopped\n * or if there is no native node after the given logical node in the same native parent.\n */\nfunction findNextRNodeSibling(node, stopNode) {\n    var currentNode = node;\n    while (currentNode && currentNode !== stopNode) {\n        var pNextOrParent = currentNode.pNextOrParent;\n        if (pNextOrParent) {\n            while (pNextOrParent.type !== 1 /* Projection */) {\n                var nativeNode = findFirstRNode(pNextOrParent);\n                if (nativeNode) {\n                    return nativeNode;\n                }\n                pNextOrParent = (pNextOrParent.pNextOrParent);\n            }\n            currentNode = pNextOrParent;\n        }\n        else {\n            var currentSibling = currentNode.next;\n            while (currentSibling) {\n                var nativeNode = findFirstRNode(currentSibling);\n                if (nativeNode) {\n                    return nativeNode;\n                }\n                currentSibling = currentSibling.next;\n            }\n            var parentNode = currentNode.parent;\n            currentNode = null;\n            if (parentNode) {\n                var parentType = parentNode.type;\n                if (parentType === 0 /* Container */ || parentType === 2 /* View */) {\n                    currentNode = parentNode;\n                }\n            }\n        }\n    }\n    return null;\n}\n/**\n * Get the next node in the LNode tree, taking into account the place where a node is\n * projected (in the shadow DOM) rather than where it comes from (in the light DOM).\n *\n * @param node The node whose next node in the LNode tree must be found.\n * @return LNode|null The next sibling in the LNode tree.\n */\nfunction getNextLNodeWithProjection(node) {\n    var pNextOrParent = node.pNextOrParent;\n    if (pNextOrParent) {\n        // The node is projected\n        var isLastProjectedNode = pNextOrParent.type === 1;\n        // returns pNextOrParent if we are not at the end of the list, null otherwise\n        return isLastProjectedNode ? null : pNextOrParent;\n    }\n    // returns node.next because the the node is not projected\n    return node.next;\n}\n/**\n * Find the next node in the LNode tree, taking into account the place where a node is\n * projected (in the shadow DOM) rather than where it comes from (in the light DOM).\n *\n * If there is no sibling node, this function goes to the next sibling of the parent node...\n * until it reaches rootNode (at which point null is returned).\n *\n * @param initialNode The node whose following node in the LNode tree must be found.\n * @param rootNode The root node at which the lookup should stop.\n * @return LNode|null The following node in the LNode tree.\n */\nfunction getNextOrParentSiblingNode(initialNode, rootNode) {\n    var node = initialNode;\n    var nextNode = getNextLNodeWithProjection(node);\n    while (node && !nextNode) {\n        // if node.pNextOrParent is not null here, it is not the next node\n        // (because, at this point, nextNode is null, so it is the parent)\n        node = node.pNextOrParent || node.parent;\n        if (node === rootNode) {\n            return null;\n        }\n        nextNode = node && getNextLNodeWithProjection(node);\n    }\n    return nextNode;\n}\n/**\n * Returns the first RNode inside the given LNode.\n *\n * @param node The node whose first DOM node must be found\n * @returns RNode The first RNode of the given LNode or null if there is none.\n */\nfunction findFirstRNode(rootNode) {\n    var node = rootNode;\n    while (node) {\n        var nextNode = null;\n        if (node.type === 3 /* Element */) {\n            // A LElementNode has a matching RNode in LElementNode.native\n            return node.native;\n        }\n        else if (node.type === 0 /* Container */) {\n            var lContainerNode = node;\n            var childContainerData = lContainerNode.dynamicLContainerNode ?\n                lContainerNode.dynamicLContainerNode.data :\n                lContainerNode.data;\n            nextNode = childContainerData.views.length ? childContainerData.views[0].child : null;\n        }\n        else if (node.type === 1 /* Projection */) {\n            // For Projection look at the first projected node\n            nextNode = node.data.head;\n        }\n        else {\n            // Otherwise look at the first child\n            nextNode = node.child;\n        }\n        node = nextNode === null ? getNextOrParentSiblingNode(node, rootNode) : nextNode;\n    }\n    return null;\n}\nfunction createTextNode(value, renderer) {\n    return isProceduralRenderer(renderer) ? renderer.createText(stringify$1(value)) :\n        renderer.createTextNode(stringify$1(value));\n}\nfunction addRemoveViewFromContainer(container, rootNode, insertMode, beforeNode) {\n    ngDevMode && assertNodeType(container, 0 /* Container */);\n    ngDevMode && assertNodeType(rootNode, 2 /* View */);\n    var parentNode = container.data.renderParent;\n    var parent = parentNode ? parentNode.native : null;\n    var node = rootNode.child;\n    if (parent) {\n        while (node) {\n            var nextNode = null;\n            var renderer = container.view.renderer;\n            if (node.type === 3 /* Element */) {\n                if (insertMode) {\n                    if (!node.native) {\n                        // If the native element doesn't exist, this is a bound text node that hasn't yet been\n                        // created because update mode has not run (occurs when a bound text node is a root\n                        // node of a dynamically created view). See textBinding() in instructions for ctx.\n                        // If the native element doesn't exist, this is a bound text node that hasn't yet been\n                        // created because update mode has not run (occurs when a bound text node is a root\n                        // node of a dynamically created view). See textBinding() in instructions for ctx.\n                        node.native = createTextNode('', renderer);\n                    }\n                    isProceduralRenderer(renderer) ?\n                        renderer.insertBefore(parent, (node.native), beforeNode) :\n                        parent.insertBefore((node.native), beforeNode, true);\n                }\n                else {\n                    isProceduralRenderer(renderer) ? renderer.removeChild(parent, (node.native)) :\n                        parent.removeChild((node.native));\n                }\n                nextNode = node.next;\n            }\n            else if (node.type === 0 /* Container */) {\n                // if we get to a container, it must be a root node of a view because we are only\n                // propagating down into child views / containers and not child elements\n                var childContainerData = node.data;\n                childContainerData.renderParent = parentNode;\n                nextNode = childContainerData.views.length ? childContainerData.views[0].child : null;\n            }\n            else if (node.type === 1 /* Projection */) {\n                nextNode = node.data.head;\n            }\n            else {\n                nextNode = node.child;\n            }\n            if (nextNode === null) {\n                node = getNextOrParentSiblingNode(node, rootNode);\n            }\n            else {\n                node = nextNode;\n            }\n        }\n    }\n}\n/**\n * Traverses the tree of component views and containers to remove listeners and\n * call onDestroy callbacks.\n *\n * Notes:\n *  - Because it's used for onDestroy calls, it needs to be bottom-up.\n *  - Must process containers instead of their views to avoid splicing\n *  when views are destroyed and re-added.\n *  - Using a while loop because it's faster than recursion\n *  - Destroy only called on movement to sibling or movement to parent (laterally or up)\n *\n *  @param rootView The view to destroy\n */\nfunction destroyViewTree(rootView) {\n    var viewOrContainer = rootView;\n    while (viewOrContainer) {\n        var next = null;\n        if (viewOrContainer.views && viewOrContainer.views.length) {\n            next = viewOrContainer.views[0].data;\n        }\n        else if (viewOrContainer.child) {\n            next = viewOrContainer.child;\n        }\n        else if (viewOrContainer.next) {\n            cleanUpView(viewOrContainer);\n            next = viewOrContainer.next;\n        }\n        if (next == null) {\n            // If the viewOrContainer is the rootView, then the cleanup is done twice.\n            // Without this check, ngOnDestroy would be called twice for a directive on an element.\n            while (viewOrContainer && !viewOrContainer.next && viewOrContainer !== rootView) {\n                cleanUpView(viewOrContainer);\n                viewOrContainer = getParentState(viewOrContainer, rootView);\n            }\n            cleanUpView(viewOrContainer || rootView);\n            next = viewOrContainer && viewOrContainer.next;\n        }\n        viewOrContainer = next;\n    }\n}\n/**\n * Inserts a view into a container.\n *\n * This adds the view to the container's array of active views in the correct\n * position. It also adds the view's elements to the DOM if the container isn't a\n * root node of another view (in that case, the view's elements will be added when\n * the container's parent view is added later).\n *\n * @param container The container into which the view should be inserted\n * @param newView The view to insert\n * @param index The index at which to insert the view\n * @returns The inserted view\n */\nfunction insertView(container, newView, index) {\n    var state = container.data;\n    var views = state.views;\n    if (index > 0) {\n        // This is a new view, we need to add it to the children.\n        setViewNext(views[index - 1], newView);\n    }\n    if (index < views.length) {\n        setViewNext(newView, views[index]);\n        views.splice(index, 0, newView);\n    }\n    else {\n        views.push(newView);\n    }\n    // If the container's renderParent is null, we know that it is a root node of its own parent view\n    // and we should wait until that parent processes its nodes (otherwise, we will insert this view's\n    // nodes twice - once now and once when its parent inserts its views).\n    if (container.data.renderParent !== null) {\n        var beforeNode = findNextRNodeSibling(newView, container);\n        if (!beforeNode) {\n            var containerNextNativeNode = container.native;\n            if (containerNextNativeNode === undefined) {\n                containerNextNativeNode = container.native = findNextRNodeSibling(container, null);\n            }\n            beforeNode = containerNextNativeNode;\n        }\n        addRemoveViewFromContainer(container, newView, true, beforeNode);\n    }\n    return newView;\n}\n/**\n * Removes a view from a container.\n *\n * This method splices the view from the container's array of active views. It also\n * removes the view's elements from the DOM and conducts cleanup (e.g. removing\n * listeners, calling onDestroys).\n *\n * @param container The container from which to remove a view\n * @param removeIndex The index of the view to remove\n * @returns The removed view\n */\nfunction removeView(container, removeIndex) {\n    var views = container.data.views;\n    var viewNode = views[removeIndex];\n    if (removeIndex > 0) {\n        setViewNext(views[removeIndex - 1], viewNode.next);\n    }\n    views.splice(removeIndex, 1);\n    viewNode.next = null;\n    destroyViewTree(viewNode.data);\n    addRemoveViewFromContainer(container, viewNode, false);\n    // Notify query that view has been removed\n    container.data.queries && container.data.queries.removeView(removeIndex);\n    return viewNode;\n}\n/**\n * Sets a next on the view node, so views in for loops can easily jump from\n * one view to the next to add/remove elements. Also adds the LView (view.data)\n * to the view tree for easy traversal when cleaning up the view.\n *\n * @param view The view to set up\n * @param next The view's new next\n */\nfunction setViewNext(view, next) {\n    view.next = next;\n    view.data.next = next ? next.data : null;\n}\n/**\n * Determines which LViewOrLContainer to jump to when traversing back up the\n * tree in destroyViewTree.\n *\n * Normally, the view's parent LView should be checked, but in the case of\n * embedded views, the container (which is the view node's parent, but not the\n * LView's parent) needs to be checked for a possible next property.\n *\n * @param state The LViewOrLContainer for which we need a parent state\n * @param rootView The rootView, so we don't propagate too far up the view tree\n * @returns The correct parent LViewOrLContainer\n */\nfunction getParentState(state, rootView) {\n    var node;\n    if ((node = state.node) && node.type === 2 /* View */) {\n        // if it's an embedded view, the state needs to go up to the container, in case the\n        // container has a next\n        return node.parent.data;\n    }\n    else {\n        // otherwise, use parent view for containers or component views\n        return state.parent === rootView ? null : state.parent;\n    }\n}\n/**\n * Removes all listeners and call all onDestroys in a given view.\n *\n * @param view The LView to clean up\n */\nfunction cleanUpView(view) {\n    removeListeners(view);\n    executeOnDestroys(view);\n    executePipeOnDestroys(view);\n}\n/** Removes listeners and unsubscribes from output subscriptions */\nfunction removeListeners(view) {\n    var cleanup = (view.cleanup);\n    if (cleanup != null) {\n        for (var i = 0; i < cleanup.length - 1; i += 2) {\n            if (typeof cleanup[i] === 'string') {\n                cleanup[i + 1].removeEventListener(cleanup[i], cleanup[i + 2], cleanup[i + 3]);\n                i += 2;\n            }\n            else {\n                cleanup[i].call(cleanup[i + 1]);\n            }\n        }\n        view.cleanup = null;\n    }\n}\n/** Calls onDestroy hooks for this view */\nfunction executeOnDestroys(view) {\n    var tView = view.tView;\n    var destroyHooks;\n    if (tView != null && (destroyHooks = tView.destroyHooks) != null) {\n        callHooks((view.directives), destroyHooks);\n    }\n}\n/** Calls pipe destroy hooks for this view */\nfunction executePipeOnDestroys(view) {\n    var pipeDestroyHooks = view.tView && view.tView.pipeDestroyHooks;\n    if (pipeDestroyHooks) {\n        callHooks((view.data), pipeDestroyHooks);\n    }\n}\n/**\n * Returns whether a native element should be inserted in the given parent.\n *\n * The native node can be inserted when its parent is:\n * - A regular element => Yes\n * - A component host element =>\n *    - if the `currentView` === the parent `view`: The element is in the content (vs the\n *      template)\n *      => don't add as the parent component will project if needed.\n *    - `currentView` !== the parent `view` => The element is in the template (vs the content),\n *      add it\n * - View element => delay insertion, will be done on `viewEnd()`\n *\n * @param parent The parent in which to insert the child\n * @param currentView The LView being processed\n * @return boolean Whether the child element should be inserted.\n */\nfunction canInsertNativeNode(parent, currentView) {\n    var parentIsElement = parent.type === 3;\n    return parentIsElement &&\n        (parent.view !== currentView || parent.data === null /* Regular Element. */);\n}\n/**\n * Appends the `child` element to the `parent`.\n *\n * The element insertion might be delayed {@link canInsertNativeNode}\n *\n * @param parent The parent to which to append the child\n * @param child The child that should be appended\n * @param currentView The current LView\n * @returns Whether or not the child was appended\n */\nfunction appendChild(parent, child, currentView) {\n    if (child !== null && canInsertNativeNode(parent, currentView)) {\n        // We only add element if not in View or not projected.\n        var renderer = currentView.renderer;\n        isProceduralRenderer(renderer) ? renderer.appendChild(parent.native, child) :\n            parent.native.appendChild(child);\n        return true;\n    }\n    return false;\n}\n/**\n * Inserts the provided node before the correct element in the DOM.\n *\n * The element insertion might be delayed {@link canInsertNativeNode}\n *\n * @param node Node to insert\n * @param currentView Current LView\n */\nfunction insertChild(node, currentView) {\n    var parent = (node.parent);\n    if (canInsertNativeNode(parent, currentView)) {\n        var nativeSibling = findNextRNodeSibling(node, null);\n        var renderer = currentView.renderer;\n        isProceduralRenderer(renderer) ?\n            renderer.insertBefore((parent.native), (node.native), nativeSibling) :\n            parent.native.insertBefore((node.native), nativeSibling, false);\n    }\n}\n/**\n * Appends a projected node to the DOM, or in the case of a projected container,\n * appends the nodes from all of the container's active views to the DOM.\n *\n * @param node The node to process\n * @param currentParent The last parent element to be processed\n * @param currentView Current LView\n */\nfunction appendProjectedNode(node, currentParent, currentView) {\n    if (node.type !== 0 /* Container */) {\n        appendChild(currentParent, node.native, currentView);\n    }\n    else {\n        // The node we are adding is a Container and we are adding it to Element which\n        // is not a component (no more re-projection).\n        // Alternatively a container is projected at the root of a component's template\n        // and can't be re-projected (as not content of any component).\n        // Assignee the final projection location in those cases.\n        var lContainer = node.data;\n        lContainer.renderParent = currentParent;\n        var views = lContainer.views;\n        for (var i = 0; i < views.length; i++) {\n            addRemoveViewFromContainer(node, views[i], true, null);\n        }\n    }\n    if (node.dynamicLContainerNode) {\n        node.dynamicLContainerNode.data.renderParent = currentParent;\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 */\nfunction isCssClassMatching(nodeClassAttrVal, cssClassToMatch) {\n    var nodeClassesLen = nodeClassAttrVal.length;\n    var matchIndex = nodeClassAttrVal.indexOf(cssClassToMatch);\n    var matchEndIdx = matchIndex + cssClassToMatch.length;\n    if (matchIndex === -1 // no match\n        || (matchIndex > 0 && nodeClassAttrVal[matchIndex - 1] !== ' ') // no space before\n        ||\n            (matchEndIdx < nodeClassesLen && nodeClassAttrVal[matchEndIdx] !== ' ')) {\n        return false;\n    }\n    return true;\n}\n/**\n * A utility function to match an Ivy node static data against a simple CSS selector\n *\n * @param node static data to match\n * @param selector\n * @returns true if node matches the selector.\n */\nfunction isNodeMatchingSelector(tNode, selector) {\n    ngDevMode && assertNotNull(selector[0], 'Selector should have a tag name');\n    var mode = 4;\n    var nodeAttrs = (tNode.attrs);\n    // When processing \":not\" selectors, we skip to the next \":not\" if the\n    // current one doesn't match\n    var skipToNextSelector = false;\n    for (var i = 0; i < selector.length; i++) {\n        var current = selector[i];\n        if (typeof current === 'number') {\n            // If we finish processing a :not selector and it hasn't failed, return false\n            if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {\n                return false;\n            }\n            // If we are skipping to the next :not() and this mode flag is positive,\n            // it's a part of the current :not() selector, and we should keep skipping\n            if (skipToNextSelector && isPositive(current))\n                continue;\n            skipToNextSelector = false;\n            mode = current | (mode & 1 /* NOT */);\n            continue;\n        }\n        if (skipToNextSelector)\n            continue;\n        if (mode & 4 /* ELEMENT */) {\n            mode = 2 /* ATTRIBUTE */ | mode & 1 /* NOT */;\n            if (current !== '' && current !== tNode.tagName) {\n                if (isPositive(mode))\n                    return false;\n                skipToNextSelector = true;\n            }\n        }\n        else {\n            var attrName = mode & 8 /* CLASS */ ? 'class' : current;\n            var attrIndexInNode = findAttrIndexInNode(attrName, nodeAttrs);\n            if (attrIndexInNode === -1) {\n                if (isPositive(mode))\n                    return false;\n                skipToNextSelector = true;\n                continue;\n            }\n            var selectorAttrValue = mode & 8 /* CLASS */ ? current : selector[++i];\n            if (selectorAttrValue !== '') {\n                var nodeAttrValue = nodeAttrs[attrIndexInNode + 1];\n                if (mode & 8 /* CLASS */ &&\n                    !isCssClassMatching(nodeAttrValue, selectorAttrValue) ||\n                    mode & 2 /* ATTRIBUTE */ && selectorAttrValue !== nodeAttrValue) {\n                    if (isPositive(mode))\n                        return false;\n                    skipToNextSelector = true;\n                }\n            }\n        }\n    }\n    return isPositive(mode) || skipToNextSelector;\n}\nfunction isPositive(mode) {\n    return (mode & 1 /* NOT */) === 0;\n}\nfunction findAttrIndexInNode(name, attrs) {\n    if (attrs === null)\n        return -1;\n    for (var i = 0; i < attrs.length; i += 2) {\n        if (attrs[i] === name)\n            return i;\n    }\n    return -1;\n}\nfunction isNodeMatchingSelectorList(tNode, selector) {\n    for (var i = 0; i < selector.length; i++) {\n        if (isNodeMatchingSelector(tNode, selector[i])) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction getProjectAsAttrValue(tNode) {\n    var nodeAttrs = tNode.attrs;\n    if (nodeAttrs != null) {\n        var ngProjectAsAttrIdx = nodeAttrs.indexOf(NG_PROJECT_AS_ATTR_NAME);\n        // only check for ngProjectAs in attribute names, don't accidentally match attribute's value\n        // (attribute names are stored at even indexes)\n        if ((ngProjectAsAttrIdx & 1) === 0) {\n            return nodeAttrs[ngProjectAsAttrIdx + 1];\n        }\n    }\n    return null;\n}\n/**\n * Checks a given node against matching selectors and returns\n * selector index (or 0 if none matched).\n *\n * This function takes into account the ngProjectAs attribute: if present its value will be compared\n * to the raw (un-parsed) CSS selector instead of using standard selector matching logic.\n */\nfunction matchingSelectorIndex(tNode, selectors, textSelectors) {\n    var ngProjectAsAttrVal = getProjectAsAttrValue(tNode);\n    for (var i = 0; i < selectors.length; i++) {\n        // if a node has the ngProjectAs attribute match it against unparsed selector\n        // match a node against a parsed selector only if ngProjectAs attribute is not present\n        if (ngProjectAsAttrVal === textSelectors[i] ||\n            ngProjectAsAttrVal === null && isNodeMatchingSelectorList(tNode, selectors[i])) {\n            return i + 1; // first matching selector \"captures\" a given node\n        }\n    }\n    return 0;\n}\n\n/** Called when directives inject each other (creating a circular dependency) */\nfunction throwCyclicDependencyError(token) {\n    throw new Error(\"Cannot instantiate cyclic dependency! \" + token);\n}\n/** Called when there are multiple component selectors that match a given node */\nfunction throwMultipleComponentError(tNode) {\n    throw new Error(\"Multiple components match node with tagname \" + tNode.tagName);\n}\n/** Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on. */\nfunction throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, oldValue, currValue) {\n    if (checkNoChangesMode) {\n        var msg = \"ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: '\" + oldValue + \"'. Current value: '\" + currValue + \"'.\";\n        if (creationMode) {\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        // TODO: include debug context\n        throw new Error(msg);\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 * Directive (D) sets a property on all component instances using this constant as a key and the\n * component's host node (LElement) as the value. This is used in methods like detectChanges to\n * facilitate jumping from an instance to the host node.\n */\nvar NG_HOST_SYMBOL = '__ngHostLNode__';\n/**\n * A permanent marker promise which signifies that the current CD tree is\n * clean.\n */\nvar _CLEAN_PROMISE = Promise.resolve(null);\n/**\n * Directive and element indices for top-level directive.\n *\n * Saved here to avoid re-instantiating an array on every change detection run.\n */\nvar _ROOT_DIRECTIVE_INDICES = [0, 0];\n/**\n * Token set in currentMatches while dependencies are being resolved.\n *\n * If we visit a directive that has a value set to CIRCULAR, we know we've\n * already seen it, and thus have a circular dependency.\n */\nvar CIRCULAR$2 = '__CIRCULAR__';\n/**\n * This property gets set before entering a template.\n *\n * This renderer can be one of two varieties of Renderer3:\n *\n * - ObjectedOrientedRenderer3\n *\n * This is the native browser API style, e.g. operations are methods on individual objects\n * like HTMLElement. With this style, no additional code is needed as a facade (reducing payload\n * size).\n *\n * - ProceduralRenderer3\n *\n * In non-native browser environments (e.g. platforms such as web-workers), this is the facade\n * that enables element manipulation. This also facilitates backwards compatibility with\n * Renderer2.\n */\nvar renderer;\nvar rendererFactory;\nfunction getRenderer() {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return renderer;\n}\n/** Used to set the parent property when nodes are created. */\nvar previousOrParentNode;\nfunction getPreviousOrParentNode() {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return previousOrParentNode;\n}\n/**\n * If `isParent` is:\n *  - `true`: then `previousOrParentNode` points to a parent node.\n *  - `false`: then `previousOrParentNode` points to previous node (sibling).\n */\nvar isParent;\n/**\n * Static data that corresponds to the instance-specific data array on an LView.\n *\n * Each node's static data is stored in tData at the same index that it's stored\n * in the data array. Any nodes that do not have static data store a null value in\n * tData to avoid a sparse array.\n */\nvar tData;\n/**\n * State of the current view being processed.\n *\n * NOTE: we cheat here and initialize it to `null` even thought the type does not\n * contain `null`. This is because we expect this value to be not `null` as soon\n * as we enter the view. Declaring the type as `null` would require us to place `!`\n * in most instructions since they all assume that `currentView` is defined.\n */\nvar currentView = (null);\nvar currentQueries;\nfunction getCurrentQueries(QueryType) {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return currentQueries || (currentQueries = new QueryType());\n}\n/**\n * This property gets set before entering a template.\n */\nvar creationMode;\nfunction getCreationMode() {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return creationMode;\n}\n/**\n * An array of nodes (text, element, container, etc), pipes, their bindings, and\n * any local variables that need to be stored between invocations.\n */\nvar data;\n/**\n * An array of directive instances in the current view.\n *\n * These must be stored separately from LNodes because their presence is\n * unknown at compile-time and thus space cannot be reserved in data[].\n */\nvar directives;\n/**\n * When a view is destroyed, listeners need to be released and outputs need to be\n * unsubscribed. This cleanup array stores both listener data (in chunks of 4)\n * and output data (in chunks of 2) for a particular view. Combining the arrays\n * saves on memory (70 bytes per array) and on a few bytes of code size (for two\n * separate for loops).\n *\n * If it's a listener being stored:\n * 1st index is: event name to remove\n * 2nd index is: native element\n * 3rd index is: listener function\n * 4th index is: useCapture boolean\n *\n * If it's an output subscription:\n * 1st index is: unsubscribe function\n * 2nd index is: context for function\n */\nvar cleanup;\n/**\n * In this mode, any changes in bindings will throw an ExpressionChangedAfterChecked error.\n *\n * Necessary to support ChangeDetectorRef.checkNoChanges().\n */\nvar checkNoChangesMode = false;\n/** Whether or not this is the first time the current view has been processed. */\nvar firstTemplatePass = true;\n/**\n * Swap the current state with a new state.\n *\n * For performance reasons we store the state in the top level of the module.\n * This way we minimize the number of properties to read. Whenever a new view\n * is entered we have to store the state for later, and when the view is\n * exited the state has to be restored\n *\n * @param newView New state to become active\n * @param host Element to which the View is a child of\n * @returns the previous state;\n */\nfunction enterView(newView, host) {\n    var oldView = currentView;\n    data = newView && newView.data;\n    directives = newView && newView.directives;\n    tData = newView && newView.tView.data;\n    creationMode = newView && (newView.flags & 1 /* CreationMode */) === 1 /* CreationMode */;\n    firstTemplatePass = newView && newView.tView.firstTemplatePass;\n    cleanup = newView && newView.cleanup;\n    renderer = newView && newView.renderer;\n    if (newView && newView.bindingIndex < 0) {\n        newView.bindingIndex = newView.bindingStartIndex;\n    }\n    if (host != null) {\n        previousOrParentNode = host;\n        isParent = true;\n    }\n    currentView = newView;\n    currentQueries = newView && newView.queries;\n    return oldView;\n}\n/**\n * Used in lieu of enterView to make it clear when we are exiting a child view. This makes\n * the direction of traversal (up or down the view tree) a bit clearer.\n */\nfunction leaveView(newView) {\n    if (!checkNoChangesMode) {\n        executeHooks((directives), currentView.tView.viewHooks, currentView.tView.viewCheckHooks, creationMode);\n    }\n    // Views should be clean and in update mode after being checked, so these bits are cleared\n    currentView.flags &= ~(1 /* CreationMode */ | 4 /* Dirty */);\n    currentView.lifecycleStage = 1 /* Init */;\n    currentView.bindingIndex = -1;\n    enterView(newView, null);\n}\n/**  Refreshes directives in this view and triggers any init/content hooks.  */\nfunction refreshDirectives() {\n    executeInitAndContentHooks();\n    var tView = currentView.tView;\n    // This needs to be set before children are processed to support recursive components\n    tView.firstTemplatePass = firstTemplatePass = false;\n    setHostBindings(tView.hostBindings);\n    refreshChildComponents(tView.components);\n}\n/** Sets the host bindings for the current view. */\nfunction setHostBindings(bindings) {\n    if (bindings != null) {\n        var defs = (currentView.tView.directives);\n        for (var i = 0; i < bindings.length; i += 2) {\n            var dirIndex = bindings[i];\n            var def = defs[dirIndex];\n            def.hostBindings && def.hostBindings(dirIndex, bindings[i + 1]);\n        }\n    }\n}\n/** Refreshes child components in the current view. */\nfunction refreshChildComponents(components) {\n    if (components != null) {\n        for (var i = 0; i < components.length; i += 2) {\n            componentRefresh(components[i], components[i + 1]);\n        }\n    }\n}\nfunction executeInitAndContentHooks() {\n    if (!checkNoChangesMode) {\n        var tView = currentView.tView;\n        executeInitHooks(currentView, tView, creationMode);\n        executeHooks((directives), tView.contentHooks, tView.contentCheckHooks, creationMode);\n    }\n}\nfunction createLView(viewId, renderer, tView, template, context, flags) {\n    var newView = {\n        parent: currentView,\n        id: viewId,\n        // -1 for component views\n        flags: flags | 1 /* CreationMode */ | 8 /* Attached */,\n        node: (null),\n        // until we initialize it in createNode.\n        data: [],\n        directives: null,\n        tView: tView,\n        cleanup: null,\n        renderer: renderer,\n        child: null,\n        tail: null,\n        next: null,\n        bindingStartIndex: -1,\n        bindingIndex: -1,\n        template: template,\n        context: context,\n        dynamicViewCount: 0,\n        lifecycleStage: 1 /* Init */,\n        queries: null,\n        injector: currentView && currentView.injector,\n    };\n    return newView;\n}\n/**\n * Creation of LNode object is extracted to a separate function so we always create LNode object\n * with the same shape\n * (same properties assigned in the same order).\n */\nfunction createLNodeObject(type, currentView, parent, native, state, queries) {\n    return {\n        type: type,\n        native: native,\n        view: currentView,\n        parent: parent,\n        child: null,\n        next: null,\n        nodeInjector: parent ? parent.nodeInjector : null,\n        data: state,\n        queries: queries,\n        tNode: null,\n        pNextOrParent: null,\n        dynamicLContainerNode: null\n    };\n}\nfunction createLNode(index, type, native, state) {\n    var parent = isParent ? previousOrParentNode :\n        previousOrParentNode && previousOrParentNode.parent;\n    var queries = (isParent ? currentQueries : previousOrParentNode && previousOrParentNode.queries) ||\n        parent && parent.queries && parent.queries.child();\n    var isState = state != null;\n    var node = createLNodeObject(type, currentView, parent, native, isState ? state : null, queries);\n    if ((type & 2 /* ViewOrElement */) === 2 /* ViewOrElement */ && isState) {\n        // Bit of a hack to bust through the readonly because there is a circular dep between\n        // LView and LNode.\n        ngDevMode && assertNull(state.node, 'LView.node should not have been initialized');\n        state.node = node;\n    }\n    if (index != null) {\n        // We are Element or Container\n        ngDevMode && assertDataNext(index);\n        data[index] = node;\n        // Every node adds a value to the static data array to avoid a sparse array\n        if (index >= tData.length) {\n            tData[index] = null;\n        }\n        else {\n            node.tNode = tData[index];\n        }\n        // Now link ourselves into the tree.\n        if (isParent) {\n            currentQueries = null;\n            if (previousOrParentNode.view === currentView ||\n                previousOrParentNode.type === 2 /* View */) {\n                // We are in the same view, which means we are adding content node to the parent View.\n                ngDevMode && assertNull(previousOrParentNode.child, \"previousOrParentNode's child should not have been set.\");\n                previousOrParentNode.child = node;\n            }\n            else {\n                // We are adding component view, so we don't link parent node child to this node.\n            }\n        }\n        else if (previousOrParentNode) {\n            ngDevMode && assertNull(previousOrParentNode.next, \"previousOrParentNode's next property should not have been set \" + index + \".\");\n            previousOrParentNode.next = node;\n            if (previousOrParentNode.dynamicLContainerNode) {\n                previousOrParentNode.dynamicLContainerNode.next = node;\n            }\n        }\n    }\n    previousOrParentNode = node;\n    isParent = true;\n    return node;\n}\n/**\n * Resets the application state.\n */\nfunction resetApplicationState() {\n    isParent = false;\n    previousOrParentNode = (null);\n}\n/**\n *\n * @param hostNode Existing node to render into.\n * @param template Template function with the instructions.\n * @param context to pass into the template.\n * @param providedRendererFactory renderer factory to use\n * @param host The host element node to use\n * @param directives Directive defs that should be used for matching\n * @param pipes Pipe defs that should be used for matching\n */\n\nfunction renderEmbeddedTemplate(viewNode, template, context, renderer, directives, pipes) {\n    var _isParent = isParent;\n    var _previousOrParentNode = previousOrParentNode;\n    var oldView;\n    try {\n        isParent = true;\n        previousOrParentNode = (null);\n        var rf = 2;\n        if (viewNode == null) {\n            var tView = getOrCreateTView(template, directives || null, pipes || null);\n            var lView = createLView(-1, renderer, tView, template, context, 2 /* CheckAlways */);\n            viewNode = createLNode(null, 2 /* View */, null, lView);\n            rf = 1 /* Create */;\n        }\n        oldView = enterView(viewNode.data, viewNode);\n        template(rf, context);\n        refreshDirectives();\n        refreshDynamicChildren();\n    }\n    finally {\n        leaveView((oldView));\n        isParent = _isParent;\n        previousOrParentNode = _previousOrParentNode;\n    }\n    return viewNode;\n}\nfunction renderComponentOrTemplate(node, hostView, componentOrContext, template) {\n    var oldView = enterView(hostView, node);\n    try {\n        if (rendererFactory.begin) {\n            rendererFactory.begin();\n        }\n        if (template) {\n            template(getRenderFlags(hostView), (componentOrContext));\n            refreshDynamicChildren();\n            refreshDirectives();\n        }\n        else {\n            executeInitAndContentHooks();\n            // Element was stored at 0 in data and directive was stored at 0 in directives\n            // in renderComponent()\n            setHostBindings(_ROOT_DIRECTIVE_INDICES);\n            componentRefresh(0, 0);\n        }\n    }\n    finally {\n        if (rendererFactory.end) {\n            rendererFactory.end();\n        }\n        leaveView(oldView);\n    }\n}\n/**\n * This function returns the default configuration of rendering flags depending on when the\n * template is in creation mode or update mode. By default, the update block is run with the\n * creation block when the view is in creation mode. Otherwise, the update block is run\n * alone.\n *\n * Dynamically created views do NOT use this configuration (update block and create block are\n * always run separately).\n */\nfunction getRenderFlags(view) {\n    return view.flags & 1 /* CreationMode */ ? 1 /* Create */ | 2 /* Update */ :\n        2 /* Update */;\n}\n/**\n * Create DOM element. The instruction must later be followed by `elementEnd()` call.\n *\n * @param index Index of the element in the data array\n * @param name Name of the DOM Node\n * @param attrs Statically bound set of attributes to be written into the DOM element on creation.\n * @param localRefs A set of local reference bindings on the element.\n *\n * Attributes and localRefs are passed as an array of strings where elements with an even index\n * hold an attribute name and elements with an odd index hold an attribute value, ex.:\n * ['id', 'warning5', 'class', 'alert']\n */\nfunction elementStart(index, name, attrs, localRefs) {\n    ngDevMode &&\n        assertEqual(currentView.bindingStartIndex, -1, 'elements should be created before any bindings');\n    var native = renderer.createElement(name);\n    var node = createLNode(index, 3 /* Element */, (native), null);\n    if (attrs)\n        setUpAttributes(native, attrs);\n    appendChild((node.parent), native, currentView);\n    createDirectivesAndLocals(index, name, attrs, localRefs, null);\n    return native;\n}\nfunction createDirectivesAndLocals(index, name, attrs, localRefs, containerData) {\n    var node = previousOrParentNode;\n    if (firstTemplatePass) {\n        ngDevMode && assertDataInRange(index - 1);\n        node.tNode = tData[index] = createTNode(name, attrs || null, containerData);\n        cacheMatchingDirectivesForNode(node.tNode, currentView.tView, localRefs || null);\n    }\n    else {\n        instantiateDirectivesDirectly();\n    }\n    saveResolvedLocalsInData();\n}\n/**\n * On first template pass, we match each node against available directive selectors and save\n * the resulting defs in the correct instantiation order for subsequent change detection runs\n * (so dependencies are always created before the directives that inject them).\n */\nfunction cacheMatchingDirectivesForNode(tNode, tView, localRefs) {\n    // Please make sure to have explicit type for `exportsMap`. Inferred type triggers bug in tsickle.\n    var exportsMap = localRefs ? { '': -1 } : null;\n    var matches = tView.currentMatches = findDirectiveMatches(tNode);\n    if (matches) {\n        for (var i = 0; i < matches.length; i += 2) {\n            var def = matches[i];\n            var valueIndex = i + 1;\n            resolveDirective(def, valueIndex, matches, tView);\n            saveNameToExportMap(matches[valueIndex], def, exportsMap);\n        }\n    }\n    if (exportsMap)\n        cacheMatchingLocalNames(tNode, localRefs, exportsMap);\n}\n/** Matches the current node against all available selectors. */\nfunction findDirectiveMatches(tNode) {\n    var registry = currentView.tView.directiveRegistry;\n    var matches = null;\n    if (registry) {\n        for (var i = 0; i < registry.length; i++) {\n            var def = registry[i];\n            if (isNodeMatchingSelectorList(tNode, (def.selectors))) {\n                if (def.template) {\n                    if (tNode.flags & 4096 /* isComponent */)\n                        throwMultipleComponentError(tNode);\n                    tNode.flags = 4096 /* isComponent */;\n                }\n                if (def.diPublic)\n                    def.diPublic(def);\n                (matches || (matches = [])).push(def, null);\n            }\n        }\n    }\n    return matches;\n}\nfunction resolveDirective(def, valueIndex, matches, tView) {\n    if (matches[valueIndex] === null) {\n        matches[valueIndex] = CIRCULAR$2;\n        var instance = def.factory();\n        (tView.directives || (tView.directives = [])).push(def);\n        return directiveCreate(matches[valueIndex] = tView.directives.length - 1, instance, def);\n    }\n    else if (matches[valueIndex] === CIRCULAR$2) {\n        // If we revisit this directive before it's resolved, we know it's circular\n        throwCyclicDependencyError(def.type);\n    }\n    return null;\n}\n/** Stores index of component's host element so it will be queued for view refresh during CD. */\nfunction queueComponentIndexForCheck(dirIndex) {\n    if (firstTemplatePass) {\n        (currentView.tView.components || (currentView.tView.components = [])).push(dirIndex, data.length - 1);\n    }\n}\n/** Stores index of directive and host element so it will be queued for binding refresh during CD.\n */\nfunction queueHostBindingForCheck(dirIndex) {\n    ngDevMode &&\n        assertEqual(firstTemplatePass, true, 'Should only be called in first template pass.');\n    (currentView.tView.hostBindings || (currentView.tView.hostBindings = [])).push(dirIndex, data.length - 1);\n}\n/** Sets the context for a ChangeDetectorRef to the given instance. */\nfunction initChangeDetectorIfExisting(injector, instance, view) {\n    if (injector && injector.changeDetectorRef != null) {\n        injector.changeDetectorRef._setComponentContext(view, instance);\n    }\n}\nfunction isComponent(tNode) {\n    return (tNode.flags & 4096 /* isComponent */) === 4096 /* isComponent */;\n}\n/**\n * This function instantiates the given directives.\n */\nfunction instantiateDirectivesDirectly() {\n    var tNode = (previousOrParentNode.tNode);\n    var count = tNode.flags & 4095;\n    if (count > 0) {\n        var start = tNode.flags >> 13;\n        var end = start + count;\n        var tDirectives = (currentView.tView.directives);\n        for (var i = start; i < end; i++) {\n            var def = tDirectives[i];\n            directiveCreate(i, def.factory(), def);\n        }\n    }\n}\n/** Caches local names and their matching directive indices for query and template lookups. */\nfunction cacheMatchingLocalNames(tNode, localRefs, exportsMap) {\n    if (localRefs) {\n        var localNames = tNode.localNames = [];\n        // Local names must be stored in tNode in the same order that localRefs are defined\n        // in the template to ensure the data is loaded in the same slots as their refs\n        // in the template (for template queries).\n        for (var i = 0; i < localRefs.length; i += 2) {\n            var index = exportsMap[localRefs[i + 1]];\n            if (index == null)\n                throw new Error(\"Export of name '\" + localRefs[i + 1] + \"' not found!\");\n            localNames.push(localRefs[i], index);\n        }\n    }\n}\n/**\n * Builds up an export map as directives are created, so local refs can be quickly mapped\n * to their directive instances.\n */\nfunction saveNameToExportMap(index, def, exportsMap) {\n    if (exportsMap) {\n        if (def.exportAs)\n            exportsMap[def.exportAs] = index;\n        if (def.template)\n            exportsMap[''] = index;\n    }\n}\n/**\n * Takes a list of local names and indices and pushes the resolved local variable values\n * to data[] in the same order as they are loaded in the template with load().\n */\nfunction saveResolvedLocalsInData() {\n    var localNames = previousOrParentNode.tNode.localNames;\n    if (localNames) {\n        for (var i = 0; i < localNames.length; i += 2) {\n            var index = localNames[i + 1];\n            var value = index === -1 ? previousOrParentNode.native : directives[index];\n            data.push(value);\n        }\n    }\n}\n/**\n * Gets TView from a template function or creates a new TView\n * if it doesn't already exist.\n *\n * @param template The template from which to get static data\n * @param directives Directive defs that should be saved on TView\n * @param pipes Pipe defs that should be saved on TView\n * @returns TView\n */\nfunction getOrCreateTView(template, directives, pipes) {\n    return template.ngPrivateData ||\n        (template.ngPrivateData = createTView(directives, pipes));\n}\n/** Creates a TView instance */\nfunction createTView(defs, pipes) {\n    return {\n        data: [],\n        directives: null,\n        firstTemplatePass: true,\n        initHooks: null,\n        checkHooks: null,\n        contentHooks: null,\n        contentCheckHooks: null,\n        viewHooks: null,\n        viewCheckHooks: null,\n        destroyHooks: null,\n        pipeDestroyHooks: null,\n        hostBindings: null,\n        components: null,\n        directiveRegistry: typeof defs === 'function' ? defs() : defs,\n        pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,\n        currentMatches: null\n    };\n}\nfunction setUpAttributes(native, attrs) {\n    ngDevMode && assertEqual(attrs.length % 2, 0, 'each attribute should have a key and a value');\n    var isProc = isProceduralRenderer(renderer);\n    for (var i = 0; i < attrs.length; i += 2) {\n        var attrName = attrs[i];\n        if (attrName !== NG_PROJECT_AS_ATTR_NAME) {\n            var attrVal = attrs[i + 1];\n            isProc ? renderer.setAttribute(native, attrName, attrVal) :\n                native.setAttribute(attrName, attrVal);\n        }\n    }\n}\nfunction createError(text, token) {\n    return new Error(\"Renderer: \" + text + \" [\" + stringify$1(token) + \"]\");\n}\n/**\n * Locates the host native element, used for bootstrapping existing nodes into rendering pipeline.\n *\n * @param elementOrSelector Render element or CSS selector to locate the element.\n */\nfunction locateHostElement(factory, elementOrSelector) {\n    ngDevMode && assertDataInRange(-1);\n    rendererFactory = factory;\n    var defaultRenderer = factory.createRenderer(null, null);\n    var rNode = typeof elementOrSelector === 'string' ?\n        (isProceduralRenderer(defaultRenderer) ?\n            defaultRenderer.selectRootElement(elementOrSelector) :\n            defaultRenderer.querySelector(elementOrSelector)) :\n        elementOrSelector;\n    if (ngDevMode && !rNode) {\n        if (typeof elementOrSelector === 'string') {\n            throw createError('Host node with selector not found:', elementOrSelector);\n        }\n        else {\n            throw createError('Host node is required:', elementOrSelector);\n        }\n    }\n    return rNode;\n}\n/**\n * Creates the host LNode.\n *\n * @param rNode Render host element.\n * @param def ComponentDef\n *\n * @returns LElementNode created\n */\nfunction hostElement(tag, rNode, def) {\n    resetApplicationState();\n    var node = createLNode(0, 3 /* Element */, rNode, createLView(-1, renderer, getOrCreateTView(def.template, def.directiveDefs, def.pipeDefs), null, null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */));\n    if (firstTemplatePass) {\n        node.tNode = createTNode(tag, null, null);\n        node.tNode.flags = 4096 /* isComponent */;\n        if (def.diPublic)\n            def.diPublic(def);\n        currentView.tView.directives = [def];\n    }\n    return node;\n}\n/**\n * Adds an event listener to the current node.\n *\n * If an output exists on one of the node's directives, it also subscribes to the output\n * and saves the subscription for later cleanup.\n *\n * @param eventName Name of the event\n * @param listenerFn The function to be called when event emits\n * @param useCapture Whether or not to use capture in event listener.\n */\nfunction listener(eventName, listenerFn, useCapture) {\n    if (useCapture === void 0) { useCapture = false; }\n    ngDevMode && assertPreviousIsParent();\n    var node = previousOrParentNode;\n    var native = node.native;\n    // In order to match current behavior, native DOM event listeners must be added for all\n    // events (including outputs).\n    var cleanupFns = cleanup || (cleanup = currentView.cleanup = []);\n    if (isProceduralRenderer(renderer)) {\n        var wrappedListener = wrapListenerWithDirtyLogic(currentView, listenerFn);\n        var cleanupFn = renderer.listen(native, eventName, wrappedListener);\n        cleanupFns.push(cleanupFn, null);\n    }\n    else {\n        var wrappedListener = wrapListenerWithDirtyAndDefault(currentView, listenerFn);\n        native.addEventListener(eventName, wrappedListener, useCapture);\n        cleanupFns.push(eventName, native, wrappedListener, useCapture);\n    }\n    var tNode = (node.tNode);\n    if (tNode.outputs === undefined) {\n        // if we create TNode here, inputs must be undefined so we know they still need to be\n        // checked\n        tNode.outputs = generatePropertyAliases(node.tNode.flags, 1 /* Output */);\n    }\n    var outputs = tNode.outputs;\n    var outputData;\n    if (outputs && (outputData = outputs[eventName])) {\n        createOutput(outputData, listenerFn);\n    }\n}\n/**\n * Iterates through the outputs associated with a particular event name and subscribes to\n * each output.\n */\nfunction createOutput(outputs, listener) {\n    for (var i = 0; i < outputs.length; i += 2) {\n        ngDevMode && assertDataInRange(outputs[i], (directives));\n        var subscription = directives[outputs[i]][outputs[i + 1]].subscribe(listener);\n        cleanup.push(subscription.unsubscribe, subscription);\n    }\n}\n/** Mark the end of the element. */\nfunction elementEnd() {\n    if (isParent) {\n        isParent = false;\n    }\n    else {\n        ngDevMode && assertHasParent();\n        previousOrParentNode = (previousOrParentNode.parent);\n    }\n    ngDevMode && assertNodeType(previousOrParentNode, 3 /* Element */);\n    var queries = previousOrParentNode.queries;\n    queries && queries.addNode(previousOrParentNode);\n    queueLifecycleHooks(previousOrParentNode.tNode.flags, currentView);\n}\n/**\n * Updates the value of removes an attribute on an Element.\n *\n * @param number index The index of the element in the data array\n * @param name name The name of the attribute.\n * @param value value The attribute is removed when value is `null` or `undefined`.\n *                  Otherwise the attribute value is set to the stringified value.\n * @param sanitizer An optional function used to sanitize the value.\n */\nfunction elementAttribute(index, name, value, sanitizer) {\n    if (value !== NO_CHANGE) {\n        var element = data[index];\n        if (value == null) {\n            isProceduralRenderer(renderer) ? renderer.removeAttribute(element.native, name) :\n                element.native.removeAttribute(name);\n        }\n        else {\n            var strValue = sanitizer == null ? stringify$1(value) : sanitizer(value);\n            isProceduralRenderer(renderer) ? renderer.setAttribute(element.native, name, strValue) :\n                element.native.setAttribute(name, strValue);\n        }\n    }\n}\n/**\n * Update a property on an Element.\n *\n * If the property name also exists as an input property on one of the element's directives,\n * the component property will be set instead of the element property. This check must\n * be conducted at runtime so child components that add new @Inputs don't have to be re-compiled.\n *\n * @param index The index of the element to update in the data array\n * @param propName Name of property. Because it is going to DOM, this is not subject to\n *        renaming as part of minification.\n * @param value New value to write.\n * @param sanitizer An optional function used to sanitize the value.\n */\nfunction elementProperty(index, propName, value, sanitizer) {\n    if (value === NO_CHANGE)\n        return;\n    var node = data[index];\n    var tNode = (node.tNode);\n    // if tNode.inputs is undefined, a listener has created outputs, but inputs haven't\n    // yet been checked\n    if (tNode && tNode.inputs === undefined) {\n        // mark inputs as checked\n        tNode.inputs = generatePropertyAliases(node.tNode.flags, 0 /* Input */);\n    }\n    var inputData = tNode && tNode.inputs;\n    var dataValue;\n    if (inputData && (dataValue = inputData[propName])) {\n        setInputsForProperty(dataValue, value);\n        markDirtyIfOnPush(node);\n    }\n    else {\n        // It is assumed that the sanitizer is only added when the compiler determines that the property\n        // is risky, so sanitization can be done without further checks.\n        value = sanitizer != null ? sanitizer(value) : value;\n        var native = node.native;\n        isProceduralRenderer(renderer) ? renderer.setProperty(native, propName, value) :\n            (native.setProperty ? native.setProperty(propName, value) :\n                native[propName] = value);\n    }\n}\n/**\n * Constructs a TNode object from the arguments.\n *\n * @param tagName\n * @param attrs\n * @param data\n * @param localNames A list of local names and their matching indices\n * @returns the TNode object\n */\nfunction createTNode(tagName, attrs, data) {\n    return {\n        flags: 0,\n        tagName: tagName,\n        attrs: attrs,\n        localNames: null,\n        initialInputs: undefined,\n        inputs: undefined,\n        outputs: undefined,\n        data: data\n    };\n}\n/**\n * Given a list of directive indices and minified input names, sets the\n * input properties on the corresponding directives.\n */\nfunction setInputsForProperty(inputs, value) {\n    for (var i = 0; i < inputs.length; i += 2) {\n        ngDevMode && assertDataInRange(inputs[i], (directives));\n        directives[inputs[i]][inputs[i + 1]] = value;\n    }\n}\n/**\n * Consolidates all inputs or outputs of all directives on this logical node.\n *\n * @param number lNodeFlags logical node flags\n * @param Direction direction whether to consider inputs or outputs\n * @returns PropertyAliases|null aggregate of all properties if any, `null` otherwise\n */\nfunction generatePropertyAliases(tNodeFlags, direction) {\n    var count = tNodeFlags & 4095;\n    var propStore = null;\n    if (count > 0) {\n        var start = tNodeFlags >> 13;\n        var end = start + count;\n        var isInput = direction === 0;\n        var defs = (currentView.tView.directives);\n        for (var i = start; i < end; i++) {\n            var directiveDef = defs[i];\n            var propertyAliasMap = isInput ? directiveDef.inputs : directiveDef.outputs;\n            for (var publicName in propertyAliasMap) {\n                if (propertyAliasMap.hasOwnProperty(publicName)) {\n                    propStore = propStore || {};\n                    var internalName = propertyAliasMap[publicName];\n                    var hasProperty = propStore.hasOwnProperty(publicName);\n                    hasProperty ? propStore[publicName].push(i, internalName) :\n                        (propStore[publicName] = [i, internalName]);\n                }\n            }\n        }\n    }\n    return propStore;\n}\n/**\n * Add or remove a class in a `classList` on a DOM element.\n *\n * This instruction is meant to handle the [class.foo]=\"exp\" case\n *\n * @param index The index of the element to update in the data array\n * @param className Name of class to toggle. Because it is going to DOM, this is not subject to\n *        renaming as part of minification.\n * @param value A value indicating if a given class should be added or removed.\n */\nfunction elementClassNamed(index, className, value) {\n    if (value !== NO_CHANGE) {\n        var lElement = data[index];\n        if (value) {\n            isProceduralRenderer(renderer) ? renderer.addClass(lElement.native, className) :\n                lElement.native.classList.add(className);\n        }\n        else {\n            isProceduralRenderer(renderer) ? renderer.removeClass(lElement.native, className) :\n                lElement.native.classList.remove(className);\n        }\n    }\n}\n/**\n * Set the `className` property on a DOM element.\n *\n * This instruction is meant to handle the `[class]=\"exp\"` usage.\n *\n * `elementClass` instruction writes the value to the \"element's\" `className` property.\n *\n * @param index The index of the element to update in the data array\n * @param value A value indicating a set of classes which should be applied. The method overrides\n *   any existing classes. The value is stringified (`toString`) before it is applied to the\n *   element.\n */\nfunction elementClass(index, value) {\n    if (value !== NO_CHANGE) {\n        // TODO: This is a naive implementation which simply writes value to the `className`. In the\n        // future\n        // we will add logic here which would work with the animation code.\n        var lElement = data[index];\n        isProceduralRenderer(renderer) ? renderer.setProperty(lElement.native, 'className', value) :\n            lElement.native['className'] = stringify$1(value);\n    }\n}\nfunction elementStyleNamed(index, styleName, value, suffixOrSanitizer) {\n    if (value !== NO_CHANGE) {\n        var lElement = data[index];\n        if (value == null) {\n            isProceduralRenderer(renderer) ?\n                renderer.removeStyle(lElement.native, styleName, RendererStyleFlags3.DashCase) :\n                lElement.native['style'].removeProperty(styleName);\n        }\n        else {\n            var strValue = typeof suffixOrSanitizer == 'function' ? suffixOrSanitizer(value) : stringify$1(value);\n            if (typeof suffixOrSanitizer == 'string')\n                strValue = strValue + suffixOrSanitizer;\n            isProceduralRenderer(renderer) ?\n                renderer.setStyle(lElement.native, styleName, strValue, RendererStyleFlags3.DashCase) :\n                lElement.native['style'].setProperty(styleName, strValue);\n        }\n    }\n}\n/**\n * Set the `style` property on a DOM element.\n *\n * This instruction is meant to handle the `[style]=\"exp\"` usage.\n *\n *\n * @param index The index of the element to update in the data array\n * @param value A value indicating if a given style should be added or removed.\n *   The expected shape of `value` is an object where keys are style names and the values\n *   are their corresponding values to set. If value is falsy than the style is remove. An absence\n *   of style does not cause that style to be removed. `NO_CHANGE` implies that no update should be\n *   performed.\n */\nfunction elementStyle(index, value) {\n    if (value !== NO_CHANGE) {\n        // TODO: This is a naive implementation which simply writes value to the `style`. In the future\n        // we will add logic here which would work with the animation code.\n        var lElement = data[index];\n        if (isProceduralRenderer(renderer)) {\n            renderer.setProperty(lElement.native, 'style', value);\n        }\n        else {\n            var style = lElement.native['style'];\n            for (var i = 0, keys = Object.keys(value); i < keys.length; i++) {\n                var styleName = keys[i];\n                var styleValue = value[styleName];\n                styleValue == null ? style.removeProperty(styleName) :\n                    style.setProperty(styleName, styleValue);\n            }\n        }\n    }\n}\n/**\n * Create static text node\n *\n * @param index Index of the node in the data array.\n * @param value Value to write. This value will be stringified.\n *   If value is not provided than the actual creation of the text node is delayed.\n */\nfunction text(index, value) {\n    ngDevMode &&\n        assertEqual(currentView.bindingStartIndex, -1, 'text nodes should be created before bindings');\n    var textNode = value != null ? createTextNode(value, renderer) : null;\n    var node = createLNode(index, 3 /* Element */, textNode);\n    // Text nodes are self closing.\n    isParent = false;\n    appendChild((node.parent), textNode, currentView);\n}\n/**\n * Create text node with binding\n * Bindings should be handled externally with the proper bind(1-8) method\n *\n * @param index Index of the node in the data array.\n * @param value Stringified value to write.\n */\nfunction textBinding(index, value) {\n    ngDevMode && assertDataInRange(index);\n    var existingNode = data[index];\n    ngDevMode && assertNotNull(existingNode, 'existing node');\n    if (existingNode.native) {\n        // If DOM node exists and value changed, update textContent\n        value !== NO_CHANGE &&\n            (isProceduralRenderer(renderer) ? renderer.setValue(existingNode.native, stringify$1(value)) :\n                existingNode.native.textContent = stringify$1(value));\n    }\n    else {\n        // Node was created but DOM node creation was delayed. Create and append now.\n        existingNode.native = createTextNode(value, renderer);\n        insertChild(existingNode, currentView);\n    }\n}\n/**\n * Create a directive.\n *\n * NOTE: directives can be created in order other than the index order. They can also\n *       be retrieved before they are created in which case the value will be null.\n *\n * @param directive The directive instance.\n * @param directiveDef DirectiveDef object which contains information about the template.\n */\nfunction directiveCreate(index, directive, directiveDef) {\n    var instance = baseDirectiveCreate(index, directive, directiveDef);\n    ngDevMode && assertNotNull(previousOrParentNode.tNode, 'previousOrParentNode.tNode');\n    var tNode = previousOrParentNode.tNode;\n    var isComponent = directiveDef.template;\n    if (isComponent) {\n        addComponentLogic(index, directive, directiveDef);\n    }\n    if (firstTemplatePass) {\n        // Init hooks are queued now so ngOnInit is called in host components before\n        // any projected components.\n        queueInitHooks(index, directiveDef.onInit, directiveDef.doCheck, currentView.tView);\n        if (directiveDef.hostBindings)\n            queueHostBindingForCheck(index);\n    }\n    if (tNode && tNode.attrs) {\n        setInputsFromAttrs(index, instance, directiveDef.inputs, tNode);\n    }\n    return instance;\n}\nfunction addComponentLogic(index, instance, def) {\n    var tView = getOrCreateTView(def.template, def.directiveDefs, def.pipeDefs);\n    // Only component views should be added to the view tree directly. Embedded views are\n    // accessed through their containers because they may be removed / re-added later.\n    var hostView = addToViewTree(currentView, createLView(-1, rendererFactory.createRenderer(previousOrParentNode.native, def.rendererType), tView, null, null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */));\n    previousOrParentNode.data = hostView;\n    hostView.node = previousOrParentNode;\n    initChangeDetectorIfExisting(previousOrParentNode.nodeInjector, instance, hostView);\n    if (firstTemplatePass)\n        queueComponentIndexForCheck(index);\n}\n/**\n * A lighter version of directiveCreate() that is used for the root component\n *\n * This version does not contain features that we don't already support at root in\n * current Angular. Example: local refs and inputs on root component.\n */\nfunction baseDirectiveCreate(index, directive, directiveDef) {\n    ngDevMode &&\n        assertEqual(currentView.bindingStartIndex, -1, 'directives should be created before any bindings');\n    ngDevMode && assertPreviousIsParent();\n    Object.defineProperty(directive, NG_HOST_SYMBOL, { enumerable: false, value: previousOrParentNode });\n    if (directives == null)\n        currentView.directives = directives = [];\n    ngDevMode && assertDataNext(index, directives);\n    directives[index] = directive;\n    if (firstTemplatePass) {\n        var flags = previousOrParentNode.tNode.flags;\n        if ((flags & 4095 /* DirectiveCountMask */) === 0) {\n            // When the first directive is created:\n            // - save the index,\n            // - set the number of directives to 1\n            // When the first directive is created:\n            // - save the index,\n            // - set the number of directives to 1\n            previousOrParentNode.tNode.flags =\n                index << 13 /* DirectiveStartingIndexShift */ | flags & 4096 /* isComponent */ | 1;\n        }\n        else {\n            // Only need to bump the size when subsequent directives are created\n            ngDevMode && assertNotEqual(flags & 4095 /* DirectiveCountMask */, 4095 /* DirectiveCountMask */, 'Reached the max number of directives');\n            previousOrParentNode.tNode.flags++;\n        }\n    }\n    else {\n        var diPublic = directiveDef.diPublic;\n        if (diPublic)\n            diPublic((directiveDef));\n    }\n    if (directiveDef.attributes != null && previousOrParentNode.type == 3 /* Element */) {\n        setUpAttributes(previousOrParentNode.native, directiveDef.attributes);\n    }\n    return directive;\n}\n/**\n * Sets initial input properties on directive instances from attribute data\n *\n * @param directiveIndex Index of the directive in directives array\n * @param instance Instance of the directive on which to set the initial inputs\n * @param inputs The list of inputs from the directive def\n * @param tNode The static data for this node\n */\nfunction setInputsFromAttrs(directiveIndex, instance, inputs, tNode) {\n    var initialInputData = tNode.initialInputs;\n    if (initialInputData === undefined || directiveIndex >= initialInputData.length) {\n        initialInputData = generateInitialInputs(directiveIndex, inputs, tNode);\n    }\n    var initialInputs = initialInputData[directiveIndex];\n    if (initialInputs) {\n        for (var i = 0; i < initialInputs.length; i += 2) {\n            instance[initialInputs[i]] = initialInputs[i + 1];\n        }\n    }\n}\n/**\n * Generates initialInputData for a node and stores it in the template's static storage\n * so subsequent template invocations don't have to recalculate it.\n *\n * initialInputData is an array containing values that need to be set as input properties\n * for directives on this node, but only once on creation. We need this array to support\n * the case where you set an @Input property of a directive using attribute-like syntax.\n * e.g. if you have a `name` @Input, you can set it once like this:\n *\n * <my-component name=\"Bess\"></my-component>\n *\n * @param directiveIndex Index to store the initial input data\n * @param inputs The list of inputs from the directive def\n * @param tNode The static data on this node\n */\nfunction generateInitialInputs(directiveIndex, inputs, tNode) {\n    var initialInputData = tNode.initialInputs || (tNode.initialInputs = []);\n    initialInputData[directiveIndex] = null;\n    var attrs = (tNode.attrs);\n    for (var i = 0; i < attrs.length; i += 2) {\n        var attrName = attrs[i];\n        var minifiedInputName = inputs[attrName];\n        if (minifiedInputName !== undefined) {\n            var inputsToStore = initialInputData[directiveIndex] || (initialInputData[directiveIndex] = []);\n            inputsToStore.push(minifiedInputName, attrs[i + 1]);\n        }\n    }\n    return initialInputData;\n}\nfunction createLContainer(parentLNode, currentView, template) {\n    ngDevMode && assertNotNull(parentLNode, 'containers should have a parent');\n    return {\n        views: [],\n        nextIndex: 0,\n        // If the direct parent of the container is a view, its views will need to be added\n        // through insertView() when its parent view is being inserted:\n        renderParent: canInsertNativeNode(parentLNode, currentView) ? parentLNode : null,\n        template: template == null ? null : template,\n        next: null,\n        parent: currentView,\n        dynamicViewCount: 0,\n        queries: null\n    };\n}\n/**\n * Creates an LContainerNode.\n *\n * Only `LViewNodes` can go into `LContainerNodes`.\n *\n * @param index The index of the container in the data array\n * @param template Optional inline template\n * @param tagName The name of the container element, if applicable\n * @param attrs The attrs attached to the container, if applicable\n * @param localRefs A set of local reference bindings on the element.\n */\nfunction container(index, template, tagName, attrs, localRefs) {\n    ngDevMode && assertEqual(currentView.bindingStartIndex, -1, 'container nodes should be created before any bindings');\n    var currentParent = isParent ? previousOrParentNode : previousOrParentNode.parent;\n    var lContainer = createLContainer(currentParent, currentView, template);\n    var node = createLNode(index, 0 /* Container */, undefined, lContainer);\n    // Containers are added to the current view tree instead of their embedded views\n    // because views can be removed and re-inserted.\n    addToViewTree(currentView, node.data);\n    createDirectivesAndLocals(index, tagName || null, attrs, localRefs, []);\n    isParent = false;\n    ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);\n    var queries = node.queries;\n    if (queries) {\n        // check if a given container node matches\n        queries.addNode(node);\n        // prepare place for matching nodes from views inserted into a given container\n        lContainer.queries = queries.container();\n    }\n}\n/**\n * Sets a container up to receive views.\n *\n * @param index The index of the container in the data array\n */\nfunction containerRefreshStart(index) {\n    ngDevMode && assertDataInRange(index);\n    previousOrParentNode = data[index];\n    ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);\n    isParent = true;\n    previousOrParentNode.data.nextIndex = 0;\n    ngDevMode && assertSame(previousOrParentNode.native, undefined, \"the container's native element should not have been set yet.\");\n    if (!checkNoChangesMode) {\n        // We need to execute init hooks here so ngOnInit hooks are called in top level views\n        // before they are called in embedded views (for backwards compatibility).\n        executeInitHooks(currentView, currentView.tView, creationMode);\n    }\n}\n/**\n * Marks the end of the LContainerNode.\n *\n * Marking the end of LContainerNode is the time when to child Views get inserted or removed.\n */\nfunction containerRefreshEnd() {\n    if (isParent) {\n        isParent = false;\n    }\n    else {\n        ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);\n        ngDevMode && assertHasParent();\n        previousOrParentNode = (previousOrParentNode.parent);\n    }\n    ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);\n    var container = previousOrParentNode;\n    container.native = undefined;\n    ngDevMode && assertNodeType(container, 0 /* Container */);\n    var nextIndex = container.data.nextIndex;\n    // remove extra views at the end of the container\n    while (nextIndex < container.data.views.length) {\n        removeView(container, nextIndex);\n    }\n}\nfunction refreshDynamicChildren() {\n    for (var current = currentView.child; current !== null; current = current.next) {\n        if (current.dynamicViewCount !== 0 && current.views) {\n            var container_1 = current;\n            for (var i = 0; i < container_1.views.length; i++) {\n                var view = container_1.views[i];\n                // The directives and pipes are not needed here as an existing view is only being refreshed.\n                renderEmbeddedTemplate(view, (view.data.template), (view.data.context), renderer);\n            }\n        }\n    }\n}\n/**\n * Looks for a view with a given view block id inside a provided LContainer.\n * Removes views that need to be deleted in the process.\n *\n * @param containerNode where to search for views\n * @param startIdx starting index in the views array to search from\n * @param viewBlockId exact view block id to look for\n * @returns index of a found view or -1 if not found\n */\nfunction scanForView(containerNode, startIdx, viewBlockId) {\n    var views = containerNode.data.views;\n    for (var i = startIdx; i < views.length; i++) {\n        var viewAtPositionId = views[i].data.id;\n        if (viewAtPositionId === viewBlockId) {\n            return views[i];\n        }\n        else if (viewAtPositionId < viewBlockId) {\n            // found a view that should not be at this position - remove\n            removeView(containerNode, i);\n        }\n        else {\n            // found a view with id grater than the one we are searching for\n            // which means that required view doesn't exist and can't be found at\n            // later positions in the views array - stop the search here\n            break;\n        }\n    }\n    return null;\n}\n/**\n * Marks the start of an embedded view.\n *\n * @param viewBlockId The ID of this view\n * @return boolean Whether or not this view is in creation mode\n */\nfunction embeddedViewStart(viewBlockId) {\n    var container = (isParent ? previousOrParentNode : previousOrParentNode.parent);\n    ngDevMode && assertNodeType(container, 0 /* Container */);\n    var lContainer = container.data;\n    var viewNode = scanForView(container, lContainer.nextIndex, viewBlockId);\n    if (viewNode) {\n        previousOrParentNode = viewNode;\n        ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);\n        isParent = true;\n        enterView(viewNode.data, viewNode);\n    }\n    else {\n        // When we create a new LView, we always reset the state of the instructions.\n        var newView = createLView(viewBlockId, renderer, getOrCreateEmbeddedTView(viewBlockId, container), null, null, 2 /* CheckAlways */);\n        if (lContainer.queries) {\n            newView.queries = lContainer.queries.enterView(lContainer.nextIndex);\n        }\n        enterView(newView, viewNode = createLNode(null, 2 /* View */, null, newView));\n    }\n    return getRenderFlags(viewNode.data);\n}\n/**\n * Initialize the TView (e.g. static data) for the active embedded view.\n *\n * Each embedded view needs to set the global tData variable to the static data for\n * that view. Otherwise, the view's static data for a particular node would overwrite\n * the static data for a node in the view above it with the same index (since it's in the\n * same template).\n *\n * @param viewIndex The index of the TView in TContainer\n * @param parent The parent container in which to look for the view's static data\n * @returns TView\n */\nfunction getOrCreateEmbeddedTView(viewIndex, parent) {\n    ngDevMode && assertNodeType(parent, 0 /* Container */);\n    var tContainer = parent.tNode.data;\n    if (viewIndex >= tContainer.length || tContainer[viewIndex] == null) {\n        var tView = currentView.tView;\n        tContainer[viewIndex] = createTView(tView.directiveRegistry, tView.pipeRegistry);\n    }\n    return tContainer[viewIndex];\n}\n/** Marks the end of an embedded view. */\nfunction embeddedViewEnd() {\n    refreshDirectives();\n    isParent = false;\n    var viewNode = previousOrParentNode = currentView.node;\n    var containerNode = previousOrParentNode.parent;\n    if (containerNode) {\n        ngDevMode && assertNodeType(viewNode, 2 /* View */);\n        ngDevMode && assertNodeType(containerNode, 0 /* Container */);\n        var lContainer = containerNode.data;\n        if (creationMode) {\n            // When projected nodes are going to be inserted, the renderParent of the dynamic container\n            // used by the ViewContainerRef must be set.\n            setRenderParentInProjectedNodes(lContainer.renderParent, viewNode);\n            // it is a new view, insert it into collection of views for a given container\n            insertView(containerNode, viewNode, lContainer.nextIndex);\n        }\n        lContainer.nextIndex++;\n    }\n    leaveView((currentView.parent));\n    ngDevMode && assertEqual(isParent, false, 'isParent');\n    ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);\n}\n/**\n * For nodes which are projected inside an embedded view, this function sets the renderParent\n * of their dynamic LContainerNode.\n * @param renderParent the renderParent of the LContainer which contains the embedded view.\n * @param viewNode the embedded view.\n */\nfunction setRenderParentInProjectedNodes(renderParent, viewNode) {\n    if (renderParent != null) {\n        var node = viewNode.child;\n        while (node) {\n            if (node.type === 1 /* Projection */) {\n                var nodeToProject = node.data.head;\n                var lastNodeToProject = node.data.tail;\n                while (nodeToProject) {\n                    if (nodeToProject.dynamicLContainerNode) {\n                        nodeToProject.dynamicLContainerNode.data.renderParent = renderParent;\n                    }\n                    nodeToProject = nodeToProject === lastNodeToProject ? null : nodeToProject.pNextOrParent;\n                }\n            }\n            node = node.next;\n        }\n    }\n}\n/**\n * Refreshes components by entering the component view and processing its bindings, queries, etc.\n *\n * @param directiveIndex\n * @param elementIndex\n */\nfunction componentRefresh(directiveIndex, elementIndex) {\n    ngDevMode && assertDataInRange(elementIndex);\n    var element = data[elementIndex];\n    ngDevMode && assertNodeType(element, 3 /* Element */);\n    ngDevMode && assertNotNull(element.data, \"Component's host node should have an LView attached.\");\n    var hostView = (element.data);\n    // Only attached CheckAlways components or attached, dirty OnPush components should be checked\n    if (viewAttached(hostView) && hostView.flags & (2 /* CheckAlways */ | 4 /* Dirty */)) {\n        ngDevMode && assertDataInRange(directiveIndex, (directives));\n        var def = currentView.tView.directives[directiveIndex];\n        detectChangesInternal(hostView, element, def, getDirectiveInstance(directives[directiveIndex]));\n    }\n}\n/** Returns a boolean for whether the view is attached */\nfunction viewAttached(view) {\n    return (view.flags & 8 /* Attached */) === 8 /* Attached */;\n}\n/**\n * Instruction to distribute projectable nodes among <ng-content> occurrences in a given template.\n * It takes all the selectors from the entire component's template and decides where\n * each projected node belongs (it re-distributes nodes among \"buckets\" where each \"bucket\" is\n * backed by a selector).\n *\n * This function requires CSS selectors to be provided in 2 forms: parsed (by a compiler) and text,\n * un-parsed form.\n *\n * The parsed form is needed for efficient matching of a node against a given CSS selector.\n * The un-parsed, textual form is needed for support of the ngProjectAs attribute.\n *\n * Having a CSS selector in 2 different formats is not ideal, but alternatives have even more\n * drawbacks:\n * - having only a textual form would require runtime parsing of CSS selectors;\n * - we can't have only a parsed as we can't re-construct textual form from it (as entered by a\n * template author).\n *\n * @param selectors A collection of parsed CSS selectors\n * @param rawSelectors A collection of CSS selectors in the raw, un-parsed form\n */\nfunction projectionDef(index, selectors, textSelectors) {\n    var noOfNodeBuckets = selectors ? selectors.length + 1 : 1;\n    var distributedNodes = new Array(noOfNodeBuckets);\n    for (var i = 0; i < noOfNodeBuckets; i++) {\n        distributedNodes[i] = [];\n    }\n    var componentNode = findComponentHost(currentView);\n    var componentChild = componentNode.child;\n    while (componentChild !== null) {\n        // execute selector matching logic if and only if:\n        // - there are selectors defined\n        // - a node has a tag name / attributes that can be matched\n        if (selectors && componentChild.tNode) {\n            var matchedIdx = matchingSelectorIndex(componentChild.tNode, selectors, (textSelectors));\n            distributedNodes[matchedIdx].push(componentChild);\n        }\n        else {\n            distributedNodes[0].push(componentChild);\n        }\n        componentChild = componentChild.next;\n    }\n    ngDevMode && assertDataNext(index);\n    data[index] = distributedNodes;\n}\n/**\n * Updates the linked list of a projection node, by appending another linked list.\n *\n * @param projectionNode Projection node whose projected nodes linked list has to be updated\n * @param appendedFirst First node of the linked list to append.\n * @param appendedLast Last node of the linked list to append.\n */\nfunction appendToProjectionNode(projectionNode, appendedFirst, appendedLast) {\n    ngDevMode && assertEqual(!!appendedFirst, !!appendedLast, 'appendedFirst can be null if and only if appendedLast is also null');\n    if (!appendedLast) {\n        // nothing to append\n        return;\n    }\n    var projectionNodeData = projectionNode.data;\n    if (projectionNodeData.tail) {\n        projectionNodeData.tail.pNextOrParent = appendedFirst;\n    }\n    else {\n        projectionNodeData.head = appendedFirst;\n    }\n    projectionNodeData.tail = appendedLast;\n    appendedLast.pNextOrParent = projectionNode;\n}\n/**\n * Inserts previously re-distributed projected nodes. This instruction must be preceded by a call\n * to the projectionDef instruction.\n *\n * @param nodeIndex\n * @param localIndex - index under which distribution of projected nodes was memorized\n * @param selectorIndex - 0 means <ng-content> without any selector\n * @param attrs - attributes attached to the ng-content node, if present\n */\nfunction projection(nodeIndex, localIndex, selectorIndex, attrs) {\n    if (selectorIndex === void 0) { selectorIndex = 0; }\n    var node = createLNode(nodeIndex, 1 /* Projection */, null, { head: null, tail: null });\n    if (node.tNode == null) {\n        node.tNode = createTNode(null, attrs || null, null);\n    }\n    isParent = false; // self closing\n    var currentParent = node.parent;\n    // re-distribution of projectable nodes is memorized on a component's view level\n    var componentNode = findComponentHost(currentView);\n    // make sure that nodes to project were memorized\n    var nodesForSelector = componentNode.data.data[localIndex][selectorIndex];\n    // build the linked list of projected nodes:\n    for (var i = 0; i < nodesForSelector.length; i++) {\n        var nodeToProject = nodesForSelector[i];\n        if (nodeToProject.type === 1 /* Projection */) {\n            var previouslyProjected = nodeToProject.data;\n            appendToProjectionNode(node, previouslyProjected.head, previouslyProjected.tail);\n        }\n        else {\n            appendToProjectionNode(node, nodeToProject, nodeToProject);\n        }\n    }\n    if (canInsertNativeNode(currentParent, currentView)) {\n        ngDevMode && assertNodeType(currentParent, 3 /* Element */);\n        // process each node in the list of projected nodes:\n        var nodeToProject = node.data.head;\n        var lastNodeToProject = node.data.tail;\n        while (nodeToProject) {\n            appendProjectedNode(nodeToProject, currentParent, currentView);\n            nodeToProject = nodeToProject === lastNodeToProject ? null : nodeToProject.pNextOrParent;\n        }\n    }\n}\n/**\n * Given a current view, finds the nearest component's host (LElement).\n *\n * @param lView LView for which we want a host element node\n * @returns The host node\n */\nfunction findComponentHost(lView) {\n    var viewRootLNode = lView.node;\n    while (viewRootLNode.type === 2 /* View */) {\n        ngDevMode && assertNotNull(lView.parent, 'lView.parent');\n        lView = (lView.parent);\n        viewRootLNode = lView.node;\n    }\n    ngDevMode && assertNodeType(viewRootLNode, 3 /* Element */);\n    ngDevMode && assertNotNull(viewRootLNode.data, 'node.data');\n    return viewRootLNode;\n}\n/**\n * Adds a LView or a LContainer to the end of the current view tree.\n *\n * This structure will be used to traverse through nested views to remove listeners\n * and call onDestroy callbacks.\n *\n * @param currentView The view where LView or LContainer should be added\n * @param state The LView or LContainer to add to the view tree\n * @returns The state passed in\n */\nfunction addToViewTree(currentView, state) {\n    currentView.tail ? (currentView.tail.next = state) : (currentView.child = state);\n    currentView.tail = state;\n    return state;\n}\n/** If node is an OnPush component, marks its LView dirty. */\nfunction markDirtyIfOnPush(node) {\n    // Because data flows down the component tree, ancestors do not need to be marked dirty\n    if (node.data && !(node.data.flags & 2 /* CheckAlways */)) {\n        node.data.flags |= 4 /* Dirty */;\n    }\n}\n/**\n * Wraps an event listener so its host view and its ancestor views will be marked dirty\n * whenever the event fires. Necessary to support OnPush components.\n */\nfunction wrapListenerWithDirtyLogic(view, listenerFn) {\n    return function (e) {\n        markViewDirty(view);\n        return listenerFn(e);\n    };\n}\n/**\n * Wraps an event listener so its host view and its ancestor views will be marked dirty\n * whenever the event fires. Also wraps with preventDefault behavior.\n */\nfunction wrapListenerWithDirtyAndDefault(view, listenerFn) {\n    return function wrapListenerIn_markViewDirty(e) {\n        markViewDirty(view);\n        if (listenerFn(e) === false) {\n            e.preventDefault();\n            // Necessary for legacy browsers that don't support preventDefault (e.g. IE)\n            e.returnValue = false;\n        }\n    };\n}\n/** Marks current view and all ancestors dirty */\nfunction markViewDirty(view) {\n    var currentView = view;\n    while (currentView.parent != null) {\n        currentView.flags |= 4 /* Dirty */;\n        currentView = currentView.parent;\n    }\n    currentView.flags |= 4 /* Dirty */;\n    ngDevMode && assertNotNull(currentView.context, 'rootContext');\n    scheduleTick(currentView.context);\n}\n/**\n * Used to schedule change detection on the whole application.\n *\n * Unlike `tick`, `scheduleTick` coalesces multiple calls into one change detection run.\n * It is usually called indirectly by calling `markDirty` when the view needs to be\n * re-rendered.\n *\n * Typically `scheduleTick` uses `requestAnimationFrame` to coalesce multiple\n * `scheduleTick` requests. The scheduling function can be overridden in\n * `renderComponent`'s `scheduler` option.\n */\nfunction scheduleTick(rootContext) {\n    if (rootContext.clean == _CLEAN_PROMISE) {\n        var res_1;\n        rootContext.clean = new Promise(function (r) { return res_1 = r; });\n        rootContext.scheduler(function () {\n            tick(rootContext.component);\n            res_1(null);\n            rootContext.clean = _CLEAN_PROMISE;\n        });\n    }\n}\n/**\n * Used to perform change detection on the whole application.\n *\n * This is equivalent to `detectChanges`, but invoked on root component. Additionally, `tick`\n * executes lifecycle hooks and conditionally checks components based on their\n * `ChangeDetectionStrategy` and dirtiness.\n *\n * The preferred way to trigger change detection is to call `markDirty`. `markDirty` internally\n * schedules `tick` using a scheduler in order to coalesce multiple `markDirty` calls into a\n * single change detection run. By default, the scheduler is `requestAnimationFrame`, but can\n * be changed when calling `renderComponent` and providing the `scheduler` option.\n */\nfunction tick(component) {\n    var rootView = getRootView(component);\n    var rootComponent = rootView.context.component;\n    var hostNode = _getComponentHostLElementNode(rootComponent);\n    ngDevMode && assertNotNull(hostNode.data, 'Component host node should be attached to an LView');\n    renderComponentOrTemplate(hostNode, rootView, rootComponent);\n}\n/**\n * Retrieve the root view from any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param component any component\n */\nfunction getRootView(component) {\n    ngDevMode && assertNotNull(component, 'component');\n    var lElementNode = _getComponentHostLElementNode(component);\n    var lView = lElementNode.view;\n    while (lView.parent) {\n        lView = lView.parent;\n    }\n    return lView;\n}\n/**\n * Synchronously perform change detection on a component (and possibly its sub-components).\n *\n * This function triggers change detection in a synchronous way on a component. There should\n * be very little reason to call this function directly since a preferred way to do change\n * detection is to {@link markDirty} the component and wait for the scheduler to call this method\n * at some future point in time. This is because a single user action often results in many\n * components being invalidated and calling change detection on each component synchronously\n * would be inefficient. It is better to wait until all components are marked as dirty and\n * then perform single change detection across all of the components\n *\n * @param component The component which the change detection should be performed on.\n */\nfunction detectChanges(component) {\n    var hostNode = _getComponentHostLElementNode(component);\n    ngDevMode && assertNotNull(hostNode.data, 'Component host node should be attached to an LView');\n    var componentIndex = hostNode.tNode.flags >> 13;\n    var def = hostNode.view.tView.directives[componentIndex];\n    detectChangesInternal(hostNode.data, hostNode, def, component);\n}\n/**\n * Checks the change detector and its children, and throws if any changes are detected.\n *\n * This is used in development mode to verify that running change detection doesn't\n * introduce other changes.\n */\nfunction checkNoChanges(component) {\n    checkNoChangesMode = true;\n    try {\n        detectChanges(component);\n    }\n    finally {\n        checkNoChangesMode = false;\n    }\n}\n/** Checks the view of the component provided. Does not gate on dirty checks or execute doCheck. */\nfunction detectChangesInternal(hostView, hostNode, def, component) {\n    var oldView = enterView(hostView, hostNode);\n    var template = def.template;\n    try {\n        template(getRenderFlags(hostView), component);\n        refreshDirectives();\n        refreshDynamicChildren();\n    }\n    finally {\n        leaveView(oldView);\n    }\n}\n/**\n * Mark the component as dirty (needing change detection).\n *\n * Marking a component dirty will schedule a change detection on this\n * component at some point in the future. Marking an already dirty\n * component as dirty is a noop. Only one outstanding change detection\n * can be scheduled per component tree. (Two components bootstrapped with\n * separate `renderComponent` will have separate schedulers)\n *\n * When the root component is bootstrapped with `renderComponent`, a scheduler\n * can be provided.\n *\n * @param component Component to mark as dirty.\n */\nfunction markDirty(component) {\n    ngDevMode && assertNotNull(component, 'component');\n    var lElementNode = _getComponentHostLElementNode(component);\n    markViewDirty(lElementNode.view);\n}\n/** A special value which designates that a value has not changed. */\nvar NO_CHANGE = {};\n/**\n *  Initializes the binding start index. Will get inlined.\n *\n *  This function must be called before any binding related function is called\n *  (ie `bind()`, `interpolationX()`, `pureFunctionX()`)\n */\nfunction initBindings() {\n    ngDevMode && assertEqual(currentView.bindingStartIndex, -1, 'Binding start index should only be set once, when null');\n    ngDevMode && assertEqual(currentView.bindingIndex, -1, 'Binding index should not yet be set ' + currentView.bindingIndex);\n    currentView.bindingIndex = currentView.bindingStartIndex = data.length;\n}\n/**\n * Creates a single value binding.\n *\n * @param value Value to diff\n */\nfunction bind(value) {\n    if (currentView.bindingStartIndex < 0) {\n        initBindings();\n        return data[currentView.bindingIndex++] = value;\n    }\n    var changed = value !== NO_CHANGE && isDifferent(data[currentView.bindingIndex], value);\n    if (changed) {\n        throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, data[currentView.bindingIndex], value);\n        data[currentView.bindingIndex] = value;\n    }\n    currentView.bindingIndex++;\n    return changed ? value : NO_CHANGE;\n}\n/**\n * Create interpolation bindings with a variable number of expressions.\n *\n * If there are 1 to 8 expressions `interpolation1()` to `interpolation8()` should be used instead.\n * Those are faster because there is no need to create an array of expressions and iterate over it.\n *\n * `values`:\n * - has static text at even indexes,\n * - has evaluated expressions at odd indexes.\n *\n * Returns the concatenated string when any of the arguments changes, `NO_CHANGE` otherwise.\n */\nfunction interpolationV(values) {\n    ngDevMode && assertLessThan(2, values.length, 'should have at least 3 values');\n    ngDevMode && assertEqual(values.length % 2, 1, 'should have an odd number of values');\n    var different = false;\n    for (var i = 1; i < values.length; i += 2) {\n        // Check if bindings (odd indexes) have changed\n        bindingUpdated(values[i]) && (different = true);\n    }\n    if (!different) {\n        return NO_CHANGE;\n    }\n    // Build the updated content\n    var content = values[0];\n    for (var i = 1; i < values.length; i += 2) {\n        content += stringify$1(values[i]) + values[i + 1];\n    }\n    return content;\n}\n/**\n * Creates an interpolation binding with 1 expression.\n *\n * @param prefix static value used for concatenation only.\n * @param v0 value checked for change.\n * @param suffix static value used for concatenation only.\n */\nfunction interpolation1(prefix, v0, suffix) {\n    var different = bindingUpdated(v0);\n    return different ? prefix + stringify$1(v0) + suffix : NO_CHANGE;\n}\n/** Creates an interpolation binding with 2 expressions. */\nfunction interpolation2(prefix, v0, i0, v1, suffix) {\n    var different = bindingUpdated2(v0, v1);\n    return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + suffix : NO_CHANGE;\n}\n/** Creates an interpolation bindings with 3 expressions. */\nfunction interpolation3(prefix, v0, i0, v1, i1, v2, suffix) {\n    var different = bindingUpdated2(v0, v1);\n    different = bindingUpdated(v2) || different;\n    return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + suffix :\n        NO_CHANGE;\n}\n/** Create an interpolation binding with 4 expressions. */\nfunction interpolation4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) +\n            suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 5 expressions. */\nfunction interpolation5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated(v4) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 6 expressions. */\nfunction interpolation6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated2(v4, v5) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + i4 + stringify$1(v5) + suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 7 expressions. */\nfunction interpolation7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated2(v4, v5) || different;\n    different = bindingUpdated(v6) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 8 expressions. */\nfunction interpolation8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated4(v4, v5, v6, v7) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + i6 + stringify$1(v7) + suffix :\n        NO_CHANGE;\n}\n/** Store a value in the `data` at a given `index`. */\nfunction store(index, value) {\n    // We don't store any static data for local variables, so the first time\n    // we see the template, we should store as null to avoid a sparse array\n    if (index >= tData.length) {\n        tData[index] = null;\n    }\n    data[index] = value;\n}\n/** Retrieves a value from the `data`. */\nfunction load(index) {\n    ngDevMode && assertDataInRange(index);\n    return data[index];\n}\n/** Retrieves a value from the `directives` array. */\nfunction loadDirective(index) {\n    ngDevMode && assertNotNull(directives, 'Directives array should be defined if reading a dir.');\n    ngDevMode && assertDataInRange(index, (directives));\n    return directives[index];\n}\n/** Gets the current binding value and increments the binding index. */\nfunction consumeBinding() {\n    ngDevMode && assertDataInRange(currentView.bindingIndex);\n    ngDevMode &&\n        assertNotEqual(data[currentView.bindingIndex], NO_CHANGE, 'Stored value should never be NO_CHANGE.');\n    return data[currentView.bindingIndex++];\n}\n/** Updates binding if changed, then returns whether it was updated. */\nfunction bindingUpdated(value) {\n    ngDevMode && assertNotEqual(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');\n    if (currentView.bindingStartIndex < 0) {\n        initBindings();\n    }\n    else if (isDifferent(data[currentView.bindingIndex], value)) {\n        throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, data[currentView.bindingIndex], value);\n    }\n    else {\n        currentView.bindingIndex++;\n        return false;\n    }\n    data[currentView.bindingIndex++] = value;\n    return true;\n}\n/** Updates binding if changed, then returns the latest value. */\nfunction checkAndUpdateBinding$1(value) {\n    bindingUpdated(value);\n    return value;\n}\n/** Updates 2 bindings if changed, then returns whether either was updated. */\nfunction bindingUpdated2(exp1, exp2) {\n    var different = bindingUpdated(exp1);\n    return bindingUpdated(exp2) || different;\n}\n/** Updates 4 bindings if changed, then returns whether any was updated. */\nfunction bindingUpdated4(exp1, exp2, exp3, exp4) {\n    var different = bindingUpdated2(exp1, exp2);\n    return bindingUpdated2(exp3, exp4) || different;\n}\nfunction getTView() {\n    return currentView.tView;\n}\nfunction getDirectiveInstance(instanceOrArray) {\n    // Directives with content queries store an array in directives[directiveIndex]\n    // with the instance as the first index\n    return Array.isArray(instanceOrArray) ? instanceOrArray[0] : instanceOrArray;\n}\nfunction assertPreviousIsParent() {\n    assertEqual(isParent, true, 'previousOrParentNode should be a parent');\n}\nfunction assertHasParent() {\n    assertNotNull(previousOrParentNode.parent, 'previousOrParentNode should have a parent');\n}\nfunction assertDataInRange(index, arr) {\n    if (arr == null)\n        arr = data;\n    assertLessThan(index, arr ? arr.length : 0, 'index expected to be a valid data index');\n}\nfunction assertDataNext(index, arr) {\n    if (arr == null)\n        arr = data;\n    assertEqual(arr.length, index, \"index \" + index + \" expected to be at the end of arr (length \" + arr.length + \")\");\n}\nfunction _getComponentHostLElementNode(component) {\n    ngDevMode && assertNotNull(component, 'expecting component got null');\n    var lElementNode = component[NG_HOST_SYMBOL];\n    ngDevMode && assertNotNull(component, 'object is not a component');\n    return lElementNode;\n}\nvar CLEAN_PROMISE = _CLEAN_PROMISE;\nvar ROOT_DIRECTIVE_INDICES = _ROOT_DIRECTIVE_INDICES;\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ViewRef$1 = /** @class */ (function () {\n    function ViewRef(_view, context) {\n        this._view = _view;\n        this.context = (context);\n    }\n    /** @internal */\n    /** @internal */\n    ViewRef.prototype._setComponentContext = /** @internal */\n    function (view, context) {\n        this._view = view;\n        this.context = context;\n    };\n    ViewRef.prototype.destroy = function () {  };\n    ViewRef.prototype.onDestroy = function (callback) {  };\n    /**\n     * Marks a view and all of its ancestors dirty.\n     *\n     * It also triggers change detection by calling `scheduleTick` internally, which coalesces\n     * multiple `markForCheck` calls to into one change detection run.\n     *\n     * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is\n     * checked when it needs to be re-rendered but the two normal triggers haven't marked it\n     * dirty (i.e. inputs haven't changed and events haven't fired in the view).\n     *\n     * <!-- TODO: Add a link to a chapter on OnPush components -->\n     *\n     * ### Example ([live demo](https://stackblitz.com/edit/angular-kx7rrw))\n     *\n     * ```typescript\n     * @Component({\n     *   selector: 'my-app',\n     *   template: `Number of ticks: {{numberOfTicks}}`\n     *   changeDetection: ChangeDetectionStrategy.OnPush,\n     * })\n     * class AppComponent {\n     *   numberOfTicks = 0;\n     *\n     *   constructor(private ref: ChangeDetectorRef) {\n     *     setInterval(() => {\n     *       this.numberOfTicks++;\n     *       // the following is required, otherwise the view will not be updated\n     *       this.ref.markForCheck();\n     *     }, 1000);\n     *   }\n     * }\n     * ```\n     */\n    /**\n       * Marks a view and all of its ancestors dirty.\n       *\n       * It also triggers change detection by calling `scheduleTick` internally, which coalesces\n       * multiple `markForCheck` calls to into one change detection run.\n       *\n       * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is\n       * checked when it needs to be re-rendered but the two normal triggers haven't marked it\n       * dirty (i.e. inputs haven't changed and events haven't fired in the view).\n       *\n       * <!-- TODO: Add a link to a chapter on OnPush components -->\n       *\n       * ### Example ([live demo](https://stackblitz.com/edit/angular-kx7rrw))\n       *\n       * ```typescript\n       * @Component({\n       *   selector: 'my-app',\n       *   template: `Number of ticks: {{numberOfTicks}}`\n       *   changeDetection: ChangeDetectionStrategy.OnPush,\n       * })\n       * class AppComponent {\n       *   numberOfTicks = 0;\n       *\n       *   constructor(private ref: ChangeDetectorRef) {\n       *     setInterval(() => {\n       *       this.numberOfTicks++;\n       *       // the following is required, otherwise the view will not be updated\n       *       this.ref.markForCheck();\n       *     }, 1000);\n       *   }\n       * }\n       * ```\n       */\n    ViewRef.prototype.markForCheck = /**\n       * Marks a view and all of its ancestors dirty.\n       *\n       * It also triggers change detection by calling `scheduleTick` internally, which coalesces\n       * multiple `markForCheck` calls to into one change detection run.\n       *\n       * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is\n       * checked when it needs to be re-rendered but the two normal triggers haven't marked it\n       * dirty (i.e. inputs haven't changed and events haven't fired in the view).\n       *\n       * <!-- TODO: Add a link to a chapter on OnPush components -->\n       *\n       * ### Example ([live demo](https://stackblitz.com/edit/angular-kx7rrw))\n       *\n       * ```typescript\n       * @Component({\n       *   selector: 'my-app',\n       *   template: `Number of ticks: {{numberOfTicks}}`\n       *   changeDetection: ChangeDetectionStrategy.OnPush,\n       * })\n       * class AppComponent {\n       *   numberOfTicks = 0;\n       *\n       *   constructor(private ref: ChangeDetectorRef) {\n       *     setInterval(() => {\n       *       this.numberOfTicks++;\n       *       // the following is required, otherwise the view will not be updated\n       *       this.ref.markForCheck();\n       *     }, 1000);\n       *   }\n       * }\n       * ```\n       */\n    function () { markViewDirty(this._view); };\n    /**\n     * Detaches the view from the change detection tree.\n     *\n     * Detached views will not be checked during change detection runs until they are\n     * re-attached, even if they are dirty. `detach` can be used in combination with\n     * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change\n     * detection checks.\n     *\n     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n     * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n     *\n     * ### Example\n     *\n     * The following example defines a component with a large list of readonly data.\n     * Imagine the data changes constantly, many times per second. For performance reasons,\n     * we want to check and update the list every five seconds. We can do that by detaching\n     * the component's change detector and doing a local check every five seconds.\n     *\n     * ```typescript\n     * class DataProvider {\n     *   // in a real application the returned data will be different every time\n     *   get data() {\n     *     return [1,2,3,4,5];\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'giant-list',\n     *   template: `\n     *     <li *ngFor=\"let d of dataProvider.data\">Data {{d}}</li>\n     *   `,\n     * })\n     * class GiantList {\n     *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {\n     *     ref.detach();\n     *     setInterval(() => {\n     *       this.ref.detectChanges();\n     *     }, 5000);\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'app',\n     *   providers: [DataProvider],\n     *   template: `\n     *     <giant-list><giant-list>\n     *   `,\n     * })\n     * class App {\n     * }\n     * ```\n     */\n    /**\n       * Detaches the view from the change detection tree.\n       *\n       * Detached views will not be checked during change detection runs until they are\n       * re-attached, even if they are dirty. `detach` can be used in combination with\n       * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change\n       * detection checks.\n       *\n       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n       *\n       * ### Example\n       *\n       * The following example defines a component with a large list of readonly data.\n       * Imagine the data changes constantly, many times per second. For performance reasons,\n       * we want to check and update the list every five seconds. We can do that by detaching\n       * the component's change detector and doing a local check every five seconds.\n       *\n       * ```typescript\n       * class DataProvider {\n       *   // in a real application the returned data will be different every time\n       *   get data() {\n       *     return [1,2,3,4,5];\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'giant-list',\n       *   template: `\n       *     <li *ngFor=\"let d of dataProvider.data\">Data {{d}}</li>\n       *   `,\n       * })\n       * class GiantList {\n       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {\n       *     ref.detach();\n       *     setInterval(() => {\n       *       this.ref.detectChanges();\n       *     }, 5000);\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'app',\n       *   providers: [DataProvider],\n       *   template: `\n       *     <giant-list><giant-list>\n       *   `,\n       * })\n       * class App {\n       * }\n       * ```\n       */\n    ViewRef.prototype.detach = /**\n       * Detaches the view from the change detection tree.\n       *\n       * Detached views will not be checked during change detection runs until they are\n       * re-attached, even if they are dirty. `detach` can be used in combination with\n       * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change\n       * detection checks.\n       *\n       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n       *\n       * ### Example\n       *\n       * The following example defines a component with a large list of readonly data.\n       * Imagine the data changes constantly, many times per second. For performance reasons,\n       * we want to check and update the list every five seconds. We can do that by detaching\n       * the component's change detector and doing a local check every five seconds.\n       *\n       * ```typescript\n       * class DataProvider {\n       *   // in a real application the returned data will be different every time\n       *   get data() {\n       *     return [1,2,3,4,5];\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'giant-list',\n       *   template: `\n       *     <li *ngFor=\"let d of dataProvider.data\">Data {{d}}</li>\n       *   `,\n       * })\n       * class GiantList {\n       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {\n       *     ref.detach();\n       *     setInterval(() => {\n       *       this.ref.detectChanges();\n       *     }, 5000);\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'app',\n       *   providers: [DataProvider],\n       *   template: `\n       *     <giant-list><giant-list>\n       *   `,\n       * })\n       * class App {\n       * }\n       * ```\n       */\n    function () { this._view.flags &= ~8 /* Attached */; };\n    /**\n     * Re-attaches a view to the change detection tree.\n     *\n     * This can be used to re-attach views that were previously detached from the tree\n     * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.\n     *\n     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n     *\n     * ### Example ([live demo](https://stackblitz.com/edit/angular-ymgsxw))\n     *\n     * The following example creates a component displaying `live` data. The component will detach\n     * its change detector from the main change detector tree when the component's live property\n     * is set to false.\n     *\n     * ```typescript\n     * class DataProvider {\n     *   data = 1;\n     *\n     *   constructor() {\n     *     setInterval(() => {\n     *       this.data = this.data * 2;\n     *     }, 500);\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'live-data',\n     *   inputs: ['live'],\n     *   template: 'Data: {{dataProvider.data}}'\n     * })\n     * class LiveData {\n     *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}\n     *\n     *   set live(value) {\n     *     if (value) {\n     *       this.ref.reattach();\n     *     } else {\n     *       this.ref.detach();\n     *     }\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'my-app',\n     *   providers: [DataProvider],\n     *   template: `\n     *     Live Update: <input type=\"checkbox\" [(ngModel)]=\"live\">\n     *     <live-data [live]=\"live\"><live-data>\n     *   `,\n     * })\n     * class AppComponent {\n     *   live = true;\n     * }\n     * ```\n     */\n    /**\n       * Re-attaches a view to the change detection tree.\n       *\n       * This can be used to re-attach views that were previously detached from the tree\n       * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.\n       *\n       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n       *\n       * ### Example ([live demo](https://stackblitz.com/edit/angular-ymgsxw))\n       *\n       * The following example creates a component displaying `live` data. The component will detach\n       * its change detector from the main change detector tree when the component's live property\n       * is set to false.\n       *\n       * ```typescript\n       * class DataProvider {\n       *   data = 1;\n       *\n       *   constructor() {\n       *     setInterval(() => {\n       *       this.data = this.data * 2;\n       *     }, 500);\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'live-data',\n       *   inputs: ['live'],\n       *   template: 'Data: {{dataProvider.data}}'\n       * })\n       * class LiveData {\n       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}\n       *\n       *   set live(value) {\n       *     if (value) {\n       *       this.ref.reattach();\n       *     } else {\n       *       this.ref.detach();\n       *     }\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'my-app',\n       *   providers: [DataProvider],\n       *   template: `\n       *     Live Update: <input type=\"checkbox\" [(ngModel)]=\"live\">\n       *     <live-data [live]=\"live\"><live-data>\n       *   `,\n       * })\n       * class AppComponent {\n       *   live = true;\n       * }\n       * ```\n       */\n    ViewRef.prototype.reattach = /**\n       * Re-attaches a view to the change detection tree.\n       *\n       * This can be used to re-attach views that were previously detached from the tree\n       * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.\n       *\n       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n       *\n       * ### Example ([live demo](https://stackblitz.com/edit/angular-ymgsxw))\n       *\n       * The following example creates a component displaying `live` data. The component will detach\n       * its change detector from the main change detector tree when the component's live property\n       * is set to false.\n       *\n       * ```typescript\n       * class DataProvider {\n       *   data = 1;\n       *\n       *   constructor() {\n       *     setInterval(() => {\n       *       this.data = this.data * 2;\n       *     }, 500);\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'live-data',\n       *   inputs: ['live'],\n       *   template: 'Data: {{dataProvider.data}}'\n       * })\n       * class LiveData {\n       *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}\n       *\n       *   set live(value) {\n       *     if (value) {\n       *       this.ref.reattach();\n       *     } else {\n       *       this.ref.detach();\n       *     }\n       *   }\n       * }\n       *\n       * @Component({\n       *   selector: 'my-app',\n       *   providers: [DataProvider],\n       *   template: `\n       *     Live Update: <input type=\"checkbox\" [(ngModel)]=\"live\">\n       *     <live-data [live]=\"live\"><live-data>\n       *   `,\n       * })\n       * class AppComponent {\n       *   live = true;\n       * }\n       * ```\n       */\n    function () { this._view.flags |= 8 /* Attached */; };\n    /**\n     * Checks the view and its children.\n     *\n     * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement\n     * local change detection checks.\n     *\n     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n     * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n     *\n     * ### Example\n     *\n     * The following example defines a component with a large list of readonly data.\n     * Imagine, the data changes constantly, many times per second. For performance reasons,\n     * we want to check and update the list every five seconds.\n     *\n     * We can do that by detaching the component's change detector and doing a local change detection\n     * check every five seconds.\n     *\n     * See {@link ChangeDetectorRef#detach detach} for more information.\n     */\n    /**\n       * Checks the view and its children.\n       *\n       * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement\n       * local change detection checks.\n       *\n       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n       *\n       * ### Example\n       *\n       * The following example defines a component with a large list of readonly data.\n       * Imagine, the data changes constantly, many times per second. For performance reasons,\n       * we want to check and update the list every five seconds.\n       *\n       * We can do that by detaching the component's change detector and doing a local change detection\n       * check every five seconds.\n       *\n       * See {@link ChangeDetectorRef#detach detach} for more information.\n       */\n    ViewRef.prototype.detectChanges = /**\n       * Checks the view and its children.\n       *\n       * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement\n       * local change detection checks.\n       *\n       * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n       * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n       *\n       * ### Example\n       *\n       * The following example defines a component with a large list of readonly data.\n       * Imagine, the data changes constantly, many times per second. For performance reasons,\n       * we want to check and update the list every five seconds.\n       *\n       * We can do that by detaching the component's change detector and doing a local change detection\n       * check every five seconds.\n       *\n       * See {@link ChangeDetectorRef#detach detach} for more information.\n       */\n    function () { detectChanges(this.context); };\n    /**\n     * Checks the change detector and its children, and throws if any changes are detected.\n     *\n     * This is used in development mode to verify that running change detection doesn't\n     * introduce other changes.\n     */\n    /**\n       * Checks the change detector and its children, and throws if any changes are detected.\n       *\n       * This is used in development mode to verify that running change detection doesn't\n       * introduce other changes.\n       */\n    ViewRef.prototype.checkNoChanges = /**\n       * Checks the change detector and its children, and throws if any changes are detected.\n       *\n       * This is used in development mode to verify that running change detection doesn't\n       * introduce other changes.\n       */\n    function () { checkNoChanges(this.context); };\n    return ViewRef;\n}());\nvar EmbeddedViewRef$1 = /** @class */ (function (_super) {\n    __extends(EmbeddedViewRef, _super);\n    function EmbeddedViewRef(viewNode, template, context) {\n        var _this = _super.call(this, viewNode.data, context) || this;\n        _this._lViewNode = viewNode;\n        return _this;\n    }\n    return EmbeddedViewRef;\n}(ViewRef$1));\n/**\n * Creates a ViewRef bundled with destroy functionality.\n *\n * @param context The context for this view\n * @returns The ViewRef\n */\nfunction createViewRef(view, context) {\n    // TODO: add detectChanges back in when implementing ChangeDetectorRef.detectChanges\n    return addDestroyable(new ViewRef$1((view), context));\n}\n/**\n * Decorates an object with destroy logic (implementing the DestroyRef interface)\n * and returns the enhanced object.\n *\n * @param obj The object to decorate\n * @returns The object with destroy logic\n */\nfunction addDestroyable(obj) {\n    var destroyFn = null;\n    obj.destroyed = false;\n    obj.destroy = function () {\n        destroyFn && destroyFn.forEach(function (fn) { return fn(); });\n        this.destroyed = true;\n    };\n    obj.onDestroy = function (fn) { return (destroyFn || (destroyFn = [])).push(fn); };\n    return obj;\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 * Bootstraps a component, then creates and returns a `ComponentRef` for that component.\n *\n * @param componentType Component to bootstrap\n * @param options Optional parameters which control bootstrapping\n */\n\n// TODO: A hack to not pull in the NullInjector from @angular/core.\n\n/**\n * Bootstraps a Component into an existing host element and returns an instance\n * of the component.\n *\n * Use this function to bootstrap a component into the DOM tree. Each invocation\n * of this function will create a separate tree of components, injectors and\n * change detection cycles and lifetimes. To dynamically insert a new component\n * into an existing tree such that it shares the same injection, change detection\n * and object lifetime, use {@link ViewContainer#createComponent}.\n *\n * @param componentType Component to bootstrap\n * @param options Optional parameters which control bootstrapping\n */\nfunction renderComponent(componentType /* Type as workaround for: Microsoft/TypeScript/issues/4881 */, opts) {\n    if (opts === void 0) { opts = {}; }\n    ngDevMode && assertComponentType(componentType);\n    var rendererFactory = opts.rendererFactory || domRendererFactory3;\n    var componentDef = componentType.ngComponentDef;\n    if (componentDef.type != componentType)\n        componentDef.type = componentType;\n    var component;\n    // The first index of the first selector is the tag name.\n    var componentTag = componentDef.selectors[0][0];\n    var hostNode = locateHostElement(rendererFactory, opts.host || componentTag);\n    var rootContext = {\n        // Incomplete initialization due to circular reference.\n        component: (null),\n        scheduler: opts.scheduler || requestAnimationFrame.bind(window),\n        clean: CLEAN_PROMISE,\n    };\n    var rootView = createLView(-1, rendererFactory.createRenderer(hostNode, componentDef.rendererType), createTView(null, null), null, rootContext, componentDef.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */);\n    rootView.injector = opts.injector || null;\n    var oldView = enterView(rootView, (null));\n    var elementNode;\n    try {\n        if (rendererFactory.begin)\n            rendererFactory.begin();\n        // Create element node at index 0 in data array\n        elementNode = hostElement(componentTag, hostNode, componentDef);\n        // Create directive instance with factory() and store at index 0 in directives array\n        component = rootContext.component = baseDirectiveCreate(0, componentDef.factory(), componentDef);\n        initChangeDetectorIfExisting(elementNode.nodeInjector, component, (elementNode.data));\n        opts.hostFeatures && opts.hostFeatures.forEach(function (feature) { return feature(component, componentDef); });\n        executeInitAndContentHooks();\n        setHostBindings(ROOT_DIRECTIVE_INDICES);\n        detectChangesInternal(elementNode.data, elementNode, componentDef, component);\n    }\n    finally {\n        leaveView(oldView);\n        if (rendererFactory.end)\n            rendererFactory.end();\n    }\n    return component;\n}\n/**\n * Used to enable lifecycle hooks on the root component.\n *\n * Include this feature when calling `renderComponent` if the root component\n * you are rendering has lifecycle hooks defined. Otherwise, the hooks won't\n * be called properly.\n *\n * Example:\n *\n * ```\n * renderComponent(AppComponent, {features: [RootLifecycleHooks]});\n * ```\n */\n\n/**\n * Retrieve the root context for any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param component any component\n */\nfunction getRootContext(component) {\n    var rootContext = getRootView(component).context;\n    ngDevMode && assertNotNull(rootContext, 'rootContext');\n    return rootContext;\n}\n/**\n * Retrieve the host element of the component.\n *\n * Use this function to retrieve the host element of the component. The host\n * element is the element which the component is associated with.\n *\n * @param component Component for which the host element should be retrieved.\n */\n\n/**\n * Retrieves the rendered text for a given component.\n *\n * This function retrieves the host element of a component and\n * and then returns the `textContent` for that element. This implies\n * that the text returned will include re-projected content of\n * the component as well.\n *\n * @param component The component to return the content text for.\n */\n\n/**\n * Wait on component until it is rendered.\n *\n * This function returns a `Promise` which is resolved when the component's\n * change detection is executed. This is determined by finding the scheduler\n * associated with the `component`'s render tree and waiting until the scheduler\n * flushes. If nothing is scheduled, the function returns a resolved promise.\n *\n * Example:\n * ```\n * await whenRendered(myComponent);\n * ```\n *\n * @param component Component to wait upon\n * @returns Promise which resolves when the component is rendered.\n */\nfunction whenRendered(component) {\n    return getRootContext(component).clean;\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 * If a directive is diPublic, bloomAdd sets a property on the instance with this constant as\n * the key and the directive's unique ID as the value. This allows us to map directives to their\n * bloom filter bit for DI.\n */\nvar NG_ELEMENT_ID = '__NG_ELEMENT_ID__';\n/**\n * The number of slots in each bloom filter (used by DI). The larger this number, the fewer\n * directives that will share slots, and thus, the fewer false positives when checking for\n * the existence of a directive.\n */\nvar BLOOM_SIZE = 256;\n/** Counter used to generate unique IDs for directives. */\nvar nextNgElementId = 0;\n/**\n * Registers this directive as present in its node's injector by flipping the directive's\n * corresponding bit in the injector's bloom filter.\n *\n * @param injector The node injector in which the directive should be registered\n * @param type The directive to register\n */\nfunction bloomAdd(injector, type) {\n    var id = type[NG_ELEMENT_ID];\n    // Set a unique ID on the directive type, so if something tries to inject the directive,\n    // we can easily retrieve the ID and hash it into the bloom bit that should be checked.\n    if (id == null) {\n        id = type[NG_ELEMENT_ID] = nextNgElementId++;\n    }\n    // We only have BLOOM_SIZE (256) slots in our bloom filter (8 buckets * 32 bits each),\n    // so all unique IDs must be modulo-ed into a number from 0 - 255 to fit into the filter.\n    // This means that after 255, some directives will share slots, leading to some false positives\n    // when checking for a directive's presence.\n    var bloomBit = id % BLOOM_SIZE;\n    // Create a mask that targets the specific bit associated with the directive.\n    // JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding\n    // to bit positions 0 - 31 in a 32 bit integer.\n    var mask = 1 << bloomBit;\n    // Use the raw bloomBit number to determine which bloom filter bucket we should check\n    // e.g: bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc\n    if (bloomBit < 128) {\n        // Then use the mask to flip on the bit (0-31) associated with the directive in that bucket\n        bloomBit < 64 ? (bloomBit < 32 ? (injector.bf0 |= mask) : (injector.bf1 |= mask)) :\n            (bloomBit < 96 ? (injector.bf2 |= mask) : (injector.bf3 |= mask));\n    }\n    else {\n        bloomBit < 192 ? (bloomBit < 160 ? (injector.bf4 |= mask) : (injector.bf5 |= mask)) :\n            (bloomBit < 224 ? (injector.bf6 |= mask) : (injector.bf7 |= mask));\n    }\n}\nfunction getOrCreateNodeInjector() {\n    ngDevMode && assertPreviousIsParent();\n    return getOrCreateNodeInjectorForNode(getPreviousOrParentNode());\n}\n/**\n * Creates (or gets an existing) injector for a given element or container.\n *\n * @param node for which an injector should be retrieved / created.\n * @returns Node injector\n */\nfunction getOrCreateNodeInjectorForNode(node) {\n    var nodeInjector = node.nodeInjector;\n    var parentInjector = node.parent && node.parent.nodeInjector;\n    if (nodeInjector != parentInjector) {\n        return nodeInjector;\n    }\n    return node.nodeInjector = {\n        parent: parentInjector,\n        node: node,\n        bf0: 0,\n        bf1: 0,\n        bf2: 0,\n        bf3: 0,\n        bf4: 0,\n        bf5: 0,\n        bf6: 0,\n        bf7: 0,\n        cbf0: parentInjector == null ? 0 : parentInjector.cbf0 | parentInjector.bf0,\n        cbf1: parentInjector == null ? 0 : parentInjector.cbf1 | parentInjector.bf1,\n        cbf2: parentInjector == null ? 0 : parentInjector.cbf2 | parentInjector.bf2,\n        cbf3: parentInjector == null ? 0 : parentInjector.cbf3 | parentInjector.bf3,\n        cbf4: parentInjector == null ? 0 : parentInjector.cbf4 | parentInjector.bf4,\n        cbf5: parentInjector == null ? 0 : parentInjector.cbf5 | parentInjector.bf5,\n        cbf6: parentInjector == null ? 0 : parentInjector.cbf6 | parentInjector.bf6,\n        cbf7: parentInjector == null ? 0 : parentInjector.cbf7 | parentInjector.bf7,\n        templateRef: null,\n        viewContainerRef: null,\n        elementRef: null,\n        changeDetectorRef: null\n    };\n}\n/**\n * Makes a directive public to the DI system by adding it to an injector's bloom filter.\n *\n * @param di The node injector in which a directive will be added\n * @param def The definition of the directive to be made public\n */\nfunction diPublicInInjector(di, def) {\n    bloomAdd(di, def.type);\n}\n/**\n * Makes a directive public to the DI system by adding it to an injector's bloom filter.\n *\n * @param def The definition of the directive to be made public\n */\nfunction diPublic(def) {\n    diPublicInInjector(getOrCreateNodeInjector(), def);\n}\nfunction directiveInject(token, flags) {\n    if (flags === void 0) { flags = 0 /* Default */; }\n    return getOrCreateInjectable(getOrCreateNodeInjector(), token, flags);\n}\n/**\n * Creates an ElementRef and stores it on the injector.\n * Or, if the ElementRef already exists, retrieves the existing ElementRef.\n *\n * @returns The ElementRef instance to use\n */\n\n/**\n * Creates a TemplateRef and stores it on the injector. Or, if the TemplateRef already\n * exists, retrieves the existing TemplateRef.\n *\n * @returns The TemplateRef instance to use\n */\nfunction injectTemplateRef() {\n    return getOrCreateTemplateRef(getOrCreateNodeInjector());\n}\n/**\n * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef\n * already exists, retrieves the existing ViewContainerRef.\n *\n * @returns The ViewContainerRef instance to use\n */\nfunction injectViewContainerRef() {\n    return getOrCreateContainerRef(getOrCreateNodeInjector());\n}\n/** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */\nfunction injectChangeDetectorRef() {\n    return getOrCreateChangeDetectorRef(getOrCreateNodeInjector(), null);\n}\n/**\n * Inject static attribute value into directive constructor.\n *\n * This method is used with `factory` functions which are generated as part of\n * `defineDirective` or `defineComponent`. The method retrieves the static value\n * of an attribute. (Dynamic attributes are not supported since they are not resolved\n *  at the time of injection and can change over time.)\n *\n * # Example\n * Given:\n * ```\n * @Component(...)\n * class MyComponent {\n *   constructor(@Attribute('title') title: string) { ... }\n * }\n * ```\n * When instantiated with\n * ```\n * <my-component title=\"Hello\"></my-component>\n * ```\n *\n * Then factory method generated is:\n * ```\n * MyComponent.ngComponentDef = defineComponent({\n *   factory: () => new MyComponent(injectAttribute('title'))\n *   ...\n * })\n * ```\n *\n * @experimental\n */\nfunction injectAttribute(attrName) {\n    ngDevMode && assertPreviousIsParent();\n    var lElement = getPreviousOrParentNode();\n    ngDevMode && assertNodeType(lElement, 3 /* Element */);\n    var tElement = (lElement.tNode);\n    ngDevMode && assertNotNull(tElement, 'expecting tNode');\n    var attrs = tElement.attrs;\n    if (attrs) {\n        for (var i = 0; i < attrs.length; i = i + 2) {\n            if (attrs[i] == attrName) {\n                return attrs[i + 1];\n            }\n        }\n    }\n    return undefined;\n}\n/**\n * Creates a ViewRef and stores it on the injector as ChangeDetectorRef (public alias).\n * Or, if it already exists, retrieves the existing instance.\n *\n * @returns The ChangeDetectorRef to use\n */\nfunction getOrCreateChangeDetectorRef(di, context) {\n    if (di.changeDetectorRef)\n        return di.changeDetectorRef;\n    var currentNode = di.node;\n    if (isComponent((currentNode.tNode))) {\n        return di.changeDetectorRef = createViewRef(currentNode.data, context);\n    }\n    else if (currentNode.type === 3 /* Element */) {\n        return di.changeDetectorRef = getOrCreateHostChangeDetector(currentNode.view.node);\n    }\n    return null;\n}\n/** Gets or creates ChangeDetectorRef for the closest host component */\nfunction getOrCreateHostChangeDetector(currentNode) {\n    var hostNode = getClosestComponentAncestor(currentNode);\n    var hostInjector = hostNode.nodeInjector;\n    var existingRef = hostInjector && hostInjector.changeDetectorRef;\n    return existingRef ?\n        existingRef :\n        createViewRef(hostNode.data, hostNode.view\n            .directives[hostNode.tNode.flags >> 13 /* DirectiveStartingIndexShift */]);\n}\n/**\n * If the node is an embedded view, traverses up the view tree to return the closest\n * ancestor view that is attached to a component. If it's already a component node,\n * returns itself.\n */\nfunction getClosestComponentAncestor(node) {\n    while (node.type === 2 /* View */) {\n        node = node.view.node;\n    }\n    return node;\n}\n/**\n * Searches for an instance of the given directive type up the injector tree and returns\n * that instance if found.\n *\n * Specifically, it gets the bloom filter bit associated with the directive (see bloomHashBit),\n * checks that bit against the bloom filter structure to identify an injector that might have\n * the directive (see bloomFindPossibleInjector), then searches the directives on that injector\n * for a match.\n *\n * If not found, it will propagate up to the next parent injector until the token\n * is found or the top is reached.\n *\n * @param di Node injector where the search should start\n * @param token The directive type to search for\n * @param flags Injection flags (e.g. CheckParent)\n * @returns The instance found\n */\nfunction getOrCreateInjectable(di, token, flags) {\n    var bloomHash = bloomHashBit(token);\n    // If the token has a bloom hash, then it is a directive that is public to the injection system\n    // (diPublic). If there is no hash, fall back to the module injector.\n    if (bloomHash === null) {\n        var moduleInjector = getPreviousOrParentNode().view.injector;\n        var formerInjector = setCurrentInjector(moduleInjector);\n        try {\n            return inject(token, flags);\n        }\n        finally {\n            setCurrentInjector(formerInjector);\n        }\n    }\n    else {\n        var injector = di;\n        while (injector) {\n            // Get the closest potential matching injector (upwards in the injector tree) that\n            // *potentially* has the token.\n            injector = bloomFindPossibleInjector(injector, bloomHash);\n            // If no injector is found, we *know* that there is no ancestor injector that contains the\n            // token, so we abort.\n            if (!injector) {\n                break;\n            }\n            // At this point, we have an injector which *may* contain the token, so we step through the\n            // directives associated with the injector's corresponding node to get the directive instance.\n            var node = injector.node;\n            var flags_1 = node.tNode.flags;\n            var count = flags_1 & 4095;\n            if (count !== 0) {\n                var start = flags_1 >> 13;\n                var end = start + count;\n                var defs = (node.view.tView.directives);\n                for (var i = start; i < end; i++) {\n                    // Get the definition for the directive at this index and, if it is injectable (diPublic),\n                    // and matches the given token, return the directive instance.\n                    var directiveDef = defs[i];\n                    if (directiveDef.type === token && directiveDef.diPublic) {\n                        return getDirectiveInstance(node.view.directives[i]);\n                    }\n                }\n            }\n            // If we *didn't* find the directive for the token and we are searching the current node's\n            // injector, it's possible the directive is on this node and hasn't been created yet.\n            var instance = void 0;\n            if (injector === di && (instance = searchMatchesQueuedForCreation(node, token))) {\n                return instance;\n            }\n            // The def wasn't found anywhere on this node, so it might be a false positive.\n            // Traverse up the tree and continue searching.\n            injector = injector.parent;\n        }\n    }\n    // No directive was found for the given token.\n    // TODO: implement optional, check-self, and check-parent.\n    throw new Error('Implement');\n}\nfunction searchMatchesQueuedForCreation(node, token) {\n    var matches = node.view.tView.currentMatches;\n    if (matches) {\n        for (var i = 0; i < matches.length; i += 2) {\n            var def = matches[i];\n            if (def.type === token) {\n                return resolveDirective(def, i + 1, matches, node.view.tView);\n            }\n        }\n    }\n    return null;\n}\n/**\n * Given a directive type, this function returns the bit in an injector's bloom filter\n * that should be used to determine whether or not the directive is present.\n *\n * When the directive was added to the bloom filter, it was given a unique ID that can be\n * retrieved on the class. Since there are only BLOOM_SIZE slots per bloom filter, the directive's\n * ID must be modulo-ed by BLOOM_SIZE to get the correct bloom bit (directives share slots after\n * BLOOM_SIZE is reached).\n *\n * @param type The directive type\n * @returns The bloom bit to check for the directive\n */\nfunction bloomHashBit(type) {\n    var id = type[NG_ELEMENT_ID];\n    return typeof id === 'number' ? id % BLOOM_SIZE : null;\n}\n/**\n * Finds the closest injector that might have a certain directive.\n *\n * Each directive corresponds to a bit in an injector's bloom filter. Given the bloom bit to\n * check and a starting injector, this function traverses up injectors until it finds an\n * injector that contains a 1 for that bit in its bloom filter. A 1 indicates that the\n * injector may have that directive. It only *may* have the directive because directives begin\n * to share bloom filter bits after the BLOOM_SIZE is reached, and it could correspond to a\n * different directive sharing the bit.\n *\n * Note: We can skip checking further injectors up the tree if an injector's cbf structure\n * has a 0 for that bloom bit. Since cbf contains the merged value of all the parent\n * injectors, a 0 in the bloom bit indicates that the parents definitely do not contain\n * the directive and do not need to be checked.\n *\n * @param injector The starting node injector to check\n * @param  bloomBit The bit to check in each injector's bloom filter\n * @returns An injector that might have the directive\n */\nfunction bloomFindPossibleInjector(startInjector, bloomBit) {\n    // Create a mask that targets the specific bit associated with the directive we're looking for.\n    // JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding\n    // to bit positions 0 - 31 in a 32 bit integer.\n    var mask = 1 << bloomBit;\n    // Traverse up the injector tree until we find a potential match or until we know there *isn't* a\n    // match.\n    var injector = startInjector;\n    while (injector) {\n        // Our bloom filter size is 256 bits, which is eight 32-bit bloom filter buckets:\n        // bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc.\n        // Get the bloom filter value from the appropriate bucket based on the directive's bloomBit.\n        var value = void 0;\n        if (bloomBit < 128) {\n            value = bloomBit < 64 ? (bloomBit < 32 ? injector.bf0 : injector.bf1) :\n                (bloomBit < 96 ? injector.bf2 : injector.bf3);\n        }\n        else {\n            value = bloomBit < 192 ? (bloomBit < 160 ? injector.bf4 : injector.bf5) :\n                (bloomBit < 224 ? injector.bf6 : injector.bf7);\n        }\n        // If the bloom filter value has the bit corresponding to the directive's bloomBit flipped on,\n        // this injector is a potential match.\n        if ((value & mask) === mask) {\n            return injector;\n        }\n        // If the current injector does not have the directive, check the bloom filters for the ancestor\n        // injectors (cbf0 - cbf7). These filters capture *all* ancestor injectors.\n        if (bloomBit < 128) {\n            value = bloomBit < 64 ? (bloomBit < 32 ? injector.cbf0 : injector.cbf1) :\n                (bloomBit < 96 ? injector.cbf2 : injector.cbf3);\n        }\n        else {\n            value = bloomBit < 192 ? (bloomBit < 160 ? injector.cbf4 : injector.cbf5) :\n                (bloomBit < 224 ? injector.cbf6 : injector.cbf7);\n        }\n        // If the ancestor bloom filter value has the bit corresponding to the directive, traverse up to\n        // find the specific injector. If the ancestor bloom filter does not have the bit, we can abort.\n        injector = (value & mask) ? injector.parent : null;\n    }\n    return null;\n}\nvar ReadFromInjectorFn = /** @class */ (function () {\n    function ReadFromInjectorFn(read) {\n        this.read = read;\n    }\n    return ReadFromInjectorFn;\n}());\n/**\n * Creates an ElementRef for a given node injector and stores it on the injector.\n * Or, if the ElementRef already exists, retrieves the existing ElementRef.\n *\n * @param di The node injector where we should store a created ElementRef\n * @returns The ElementRef instance to use\n */\nfunction getOrCreateElementRef(di) {\n    return di.elementRef || (di.elementRef = new ElementRef$1(di.node.type === 0 /* Container */ ? null : di.node.native));\n}\n\n\n\n\n/** A ref to a node's native element. */\nvar ElementRef$1 = /** @class */ (function () {\n    function ElementRef(nativeElement) {\n        this.nativeElement = nativeElement;\n    }\n    return ElementRef;\n}());\n/**\n * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef\n * already exists, retrieves the existing ViewContainerRef.\n *\n * @returns The ViewContainerRef instance to use\n */\nfunction getOrCreateContainerRef(di) {\n    if (!di.viewContainerRef) {\n        var vcRefHost = di.node;\n        ngDevMode && assertNodeOfPossibleTypes(vcRefHost, 0 /* Container */, 3 /* Element */);\n        var lContainer = createLContainer((vcRefHost.parent), vcRefHost.view);\n        var lContainerNode = createLNodeObject(0 /* Container */, vcRefHost.view, (vcRefHost.parent), undefined, lContainer, null);\n        vcRefHost.dynamicLContainerNode = lContainerNode;\n        addToViewTree(vcRefHost.view, lContainer);\n        di.viewContainerRef = new ViewContainerRef$1(lContainerNode);\n    }\n    return di.viewContainerRef;\n}\n/**\n * A ref to a container that enables adding and removing views from that container\n * imperatively.\n */\nvar ViewContainerRef$1 = /** @class */ (function () {\n    function ViewContainerRef(_lContainerNode) {\n        this._lContainerNode = _lContainerNode;\n        this._viewRefs = [];\n    }\n    ViewContainerRef.prototype.clear = function () {\n        var lContainer = this._lContainerNode.data;\n        while (lContainer.views.length) {\n            this.remove(0);\n        }\n    };\n    ViewContainerRef.prototype.get = function (index) { return this._viewRefs[index] || null; };\n    Object.defineProperty(ViewContainerRef.prototype, \"length\", {\n        get: function () {\n            var lContainer = this._lContainerNode.data;\n            return lContainer.views.length;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ViewContainerRef.prototype.createEmbeddedView = function (templateRef, context, index) {\n        var viewRef = templateRef.createEmbeddedView(context || {});\n        this.insert(viewRef, index);\n        return viewRef;\n    };\n    ViewContainerRef.prototype.createComponent = function (componentFactory, index, injector, projectableNodes, ngModule) {\n        throw notImplemented();\n    };\n    ViewContainerRef.prototype.insert = function (viewRef, index) {\n        var lViewNode = viewRef._lViewNode;\n        var adjustedIdx = this._adjustIndex(index);\n        insertView(this._lContainerNode, lViewNode, adjustedIdx);\n        // invalidate cache of next sibling RNode (we do similar operation in the containerRefreshEnd\n        // instruction)\n        this._lContainerNode.native = undefined;\n        this._viewRefs.splice(adjustedIdx, 0, viewRef);\n        lViewNode.parent = this._lContainerNode;\n        // If the view is dynamic (has a template), it needs to be counted both at the container\n        // level and at the node above the container.\n        if (lViewNode.data.template !== null) {\n            // Increment the container view count.\n            this._lContainerNode.data.dynamicViewCount++;\n            // Look for the parent node and increment its dynamic view count.\n            if (this._lContainerNode.parent !== null && this._lContainerNode.parent.data !== null) {\n                ngDevMode && assertNodeOfPossibleTypes(this._lContainerNode.parent, 2 /* View */, 3 /* Element */);\n                this._lContainerNode.parent.data.dynamicViewCount++;\n            }\n        }\n        return viewRef;\n    };\n    ViewContainerRef.prototype.move = function (viewRef, newIndex) {\n        var index = this.indexOf(viewRef);\n        this.detach(index);\n        this.insert(viewRef, this._adjustIndex(newIndex));\n        return viewRef;\n    };\n    ViewContainerRef.prototype.indexOf = function (viewRef) { return this._viewRefs.indexOf(viewRef); };\n    ViewContainerRef.prototype.remove = function (index) {\n        this.detach(index);\n        // TODO(ml): proper destroy of the ViewRef, i.e. recursively destroy the LviewNode and its\n        // children, delete DOM nodes and QueryList, trigger hooks (onDestroy), destroy the renderer,\n        // detach projected nodes\n    };\n    ViewContainerRef.prototype.detach = function (index) {\n        var adjustedIdx = this._adjustIndex(index, -1);\n        removeView(this._lContainerNode, adjustedIdx);\n        return this._viewRefs.splice(adjustedIdx, 1)[0] || null;\n    };\n    ViewContainerRef.prototype._adjustIndex = function (index, shift) {\n        if (shift === void 0) { shift = 0; }\n        if (index == null) {\n            return this._lContainerNode.data.views.length + shift;\n        }\n        if (ngDevMode) {\n            assertGreaterThan(index, -1, 'index must be positive');\n            // +1 because it's legal to insert at the end.\n            assertLessThan(index, this._lContainerNode.data.views.length + 1 + shift, 'index');\n        }\n        return index;\n    };\n    return ViewContainerRef;\n}());\n/**\n * Creates a TemplateRef and stores it on the injector. Or, if the TemplateRef already\n * exists, retrieves the existing TemplateRef.\n *\n * @param di The node injector where we should store a created TemplateRef\n * @returns The TemplateRef instance to use\n */\nfunction getOrCreateTemplateRef(di) {\n    ngDevMode && assertNodeType(di.node, 0 /* Container */);\n    var data = di.node.data;\n    var tView = di.node.view.tView;\n    return di.templateRef || (di.templateRef = new TemplateRef$1(getOrCreateElementRef(di), (data.template), getRenderer(), tView.directiveRegistry, tView.pipeRegistry));\n}\nvar TemplateRef$1 = /** @class */ (function () {\n    function TemplateRef(elementRef, template, _renderer, _directives, _pipes) {\n        this._renderer = _renderer;\n        this._directives = _directives;\n        this._pipes = _pipes;\n        this.elementRef = elementRef;\n        this._template = template;\n    }\n    TemplateRef.prototype.createEmbeddedView = function (context) {\n        var viewNode = renderEmbeddedTemplate(null, this._template, context, this._renderer, this._directives, this._pipes);\n        return addDestroyable(new EmbeddedViewRef$1(viewNode, this._template, context));\n    };\n    return TemplateRef;\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 * Create a component definition object.\n *\n *\n * # Example\n * ```\n * class MyDirective {\n *   // Generated by Angular Template Compiler\n *   // [Symbol] syntax will not be supported by TypeScript until v2.7\n *   static ngComponentDef = defineComponent({\n *     ...\n *   });\n * }\n * ```\n */\nfunction defineComponent(componentDefinition) {\n    var type = componentDefinition.type;\n    var pipeTypes = (componentDefinition.pipes);\n    var directiveTypes = (componentDefinition.directives);\n    var def = {\n        type: type,\n        diPublic: null,\n        factory: componentDefinition.factory,\n        template: componentDefinition.template || (null),\n        hostBindings: componentDefinition.hostBindings || null,\n        attributes: componentDefinition.attributes || null,\n        inputs: invertObject(componentDefinition.inputs),\n        outputs: invertObject(componentDefinition.outputs),\n        rendererType: resolveRendererType2(componentDefinition.rendererType) || null,\n        exportAs: componentDefinition.exportAs,\n        onInit: type.prototype.ngOnInit || null,\n        doCheck: type.prototype.ngDoCheck || null,\n        afterContentInit: type.prototype.ngAfterContentInit || null,\n        afterContentChecked: type.prototype.ngAfterContentChecked || null,\n        afterViewInit: type.prototype.ngAfterViewInit || null,\n        afterViewChecked: type.prototype.ngAfterViewChecked || null,\n        onDestroy: type.prototype.ngOnDestroy || null,\n        onPush: componentDefinition.changeDetection === exports.ChangeDetectionStrategy.OnPush,\n        directiveDefs: directiveTypes ?\n            function () {\n                return (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)\n                    .map(extractDirectiveDef);\n            } :\n            null,\n        pipeDefs: pipeTypes ?\n            function () { return (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef); } :\n            null,\n        selectors: componentDefinition.selectors\n    };\n    var feature = componentDefinition.features;\n    feature && feature.forEach(function (fn) { return fn(def); });\n    return def;\n}\nfunction extractDirectiveDef(type) {\n    var def = type.ngComponentDef || type.ngDirectiveDef;\n    if (ngDevMode && !def) {\n        throw new Error(\"'\" + type.name + \"' is neither 'ComponentType' or 'DirectiveType'.\");\n    }\n    return def;\n}\nfunction extractPipeDef(type) {\n    var def = type.ngPipeDef;\n    if (ngDevMode && !def) {\n        throw new Error(\"'\" + type.name + \"' is not a 'PipeType'.\");\n    }\n    return def;\n}\nvar PRIVATE_PREFIX = '__ngOnChanges_';\n/**\n * Creates an NgOnChangesFeature function for a component's features list.\n *\n * It accepts an optional map of minified input property names to original property names,\n * if any input properties have a public alias.\n *\n * The NgOnChangesFeature function that is returned decorates a component with support for\n * the ngOnChanges lifecycle hook, so it should be included in any component that implements\n * that hook.\n *\n * Example usage:\n *\n * ```\n * static ngComponentDef = defineComponent({\n *   ...\n *   inputs: {name: 'publicName'},\n *   features: [NgOnChangesFeature({name: 'name'})]\n * });\n * ```\n *\n * @param inputPropertyNames Map of input property names, if they are aliased\n * @returns DirectiveDefFeature\n */\nfunction NgOnChangesFeature(inputPropertyNames) {\n    return function (definition) {\n        var inputs = definition.inputs;\n        var proto = definition.type.prototype;\n        // Place where we will store SimpleChanges if there is a change\n        Object.defineProperty(proto, PRIVATE_PREFIX, { value: undefined, writable: true });\n        var _loop_1 = function (pubKey) {\n            var minKey = inputs[pubKey];\n            var propertyName = inputPropertyNames && inputPropertyNames[minKey] || pubKey;\n            var privateMinKey = PRIVATE_PREFIX + minKey;\n            // Create a place where the actual value will be stored and make it non-enumerable\n            Object.defineProperty(proto, privateMinKey, { value: undefined, writable: true });\n            var existingDesc = Object.getOwnPropertyDescriptor(proto, minKey);\n            // create a getter and setter for property\n            Object.defineProperty(proto, minKey, {\n                get: function () {\n                    return (existingDesc && existingDesc.get) ? existingDesc.get.call(this) :\n                        this[privateMinKey];\n                },\n                set: function (value) {\n                    var simpleChanges = this[PRIVATE_PREFIX];\n                    var isFirstChange = simpleChanges === undefined;\n                    if (simpleChanges == null) {\n                        simpleChanges = this[PRIVATE_PREFIX] = {};\n                    }\n                    simpleChanges[propertyName] = new SimpleChange(this[privateMinKey], value, isFirstChange);\n                    (existingDesc && existingDesc.set) ? existingDesc.set.call(this, value) :\n                        this[privateMinKey] = value;\n                }\n            });\n        };\n        for (var pubKey in inputs) {\n            _loop_1(pubKey);\n        }\n        // If an onInit hook is defined, it will need to wrap the ngOnChanges call\n        // so the call order is changes-init-check in creation mode. In subsequent\n        // change detection runs, only the check wrapper will be called.\n        if (definition.onInit != null) {\n            definition.onInit = onChangesWrapper(definition.onInit);\n        }\n        definition.doCheck = onChangesWrapper(definition.doCheck);\n    };\n    function onChangesWrapper(delegateHook) {\n        return function () {\n            var simpleChanges = this[PRIVATE_PREFIX];\n            if (simpleChanges != null) {\n                this.ngOnChanges(simpleChanges);\n                this[PRIVATE_PREFIX] = null;\n            }\n            delegateHook && delegateHook.apply(this);\n        };\n    }\n}\nfunction PublicFeature(definition) {\n    definition.diPublic = diPublic;\n}\nvar EMPTY$1 = {};\n/** Swaps the keys and values of an object. */\nfunction invertObject(obj) {\n    if (obj == null)\n        return EMPTY$1;\n    var newObj = {};\n    for (var minifiedKey in obj) {\n        newObj[obj[minifiedKey]] = minifiedKey;\n    }\n    return newObj;\n}\n/**\n * Create a directive definition object.\n *\n * # Example\n * ```\n * class MyDirective {\n *   // Generated by Angular Template Compiler\n *   // [Symbol] syntax will not be supported by TypeScript until v2.7\n *   static ngDirectiveDef = defineDirective({\n *     ...\n *   });\n * }\n * ```\n */\nvar defineDirective = defineComponent;\n/**\n * Create a pipe definition object.\n *\n * # Example\n * ```\n * class MyPipe implements PipeTransform {\n *   // Generated by Angular Template Compiler\n *   static ngPipeDef = definePipe({\n *     ...\n *   });\n * }\n * ```\n * @param pipeDef Pipe definition generated by the compiler\n */\nfunction definePipe(pipeDef) {\n    return {\n        name: pipeDef.name,\n        n: pipeDef.factory,\n        pure: pipeDef.pure !== false,\n        onDestroy: pipeDef.type.prototype.ngOnDestroy || null\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 * If the value hasn't been saved, calls the pure function to store and return the\n * value. If it has been saved, returns the saved value.\n *\n * @param pureFn Function that returns a value\n * @returns value\n */\nfunction pureFunction0(pureFn, thisArg) {\n    return getCreationMode() ? checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg) : pureFn()) :\n        consumeBinding();\n}\n/**\n * If the value of the provided exp has changed, calls the pure function to return\n * an updated value. Or if the value has not changed, returns cached value.\n *\n * @param pureFn Function that returns an updated value\n * @param exp Updated expression value\n * @returns Updated value\n */\nfunction pureFunction1(pureFn, exp, thisArg) {\n    return bindingUpdated(exp) ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp) : pureFn(exp)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @returns Updated value\n */\nfunction pureFunction2(pureFn, exp1, exp2, thisArg) {\n    return bindingUpdated2(exp1, exp2) ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2) : pureFn(exp1, exp2)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @returns Updated value\n */\nfunction pureFunction3(pureFn, exp1, exp2, exp3, thisArg) {\n    var different = bindingUpdated2(exp1, exp2);\n    return bindingUpdated(exp3) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3) : pureFn(exp1, exp2, exp3)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @returns Updated value\n */\nfunction pureFunction4(pureFn, exp1, exp2, exp3, exp4, thisArg) {\n    return bindingUpdated4(exp1, exp2, exp3, exp4) ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4) : pureFn(exp1, exp2, exp3, exp4)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @returns Updated value\n */\nfunction pureFunction5(pureFn, exp1, exp2, exp3, exp4, exp5, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    return bindingUpdated(exp5) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5) :\n            pureFn(exp1, exp2, exp3, exp4, exp5)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @param exp6\n * @returns Updated value\n */\nfunction pureFunction6(pureFn, exp1, exp2, exp3, exp4, exp5, exp6, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    return bindingUpdated2(exp5, exp6) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6) :\n            pureFn(exp1, exp2, exp3, exp4, exp5, exp6)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @param exp6\n * @param exp7\n * @returns Updated value\n */\nfunction pureFunction7(pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    different = bindingUpdated2(exp5, exp6) || different;\n    return bindingUpdated(exp7) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6, exp7) :\n            pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @param exp6\n * @param exp7\n * @param exp8\n * @returns Updated value\n */\nfunction pureFunction8(pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    return bindingUpdated4(exp5, exp6, exp7, exp8) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8) :\n            pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8)) :\n        consumeBinding();\n}\n/**\n * pureFunction instruction that can support any number of bindings.\n *\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn A pure function that takes binding values and builds an object or array\n * containing those values.\n * @param exp An array of binding values\n * @returns Updated value\n */\nfunction pureFunctionV(pureFn, exps, thisArg) {\n    var different = false;\n    for (var i = 0; i < exps.length; i++) {\n        bindingUpdated(exps[i]) && (different = true);\n    }\n    return different ? checkAndUpdateBinding$1(pureFn.apply(thisArg, exps)) : consumeBinding();\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 * Create a pipe.\n *\n * @param index Pipe index where the pipe will be stored.\n * @param pipeName The name of the pipe\n * @returns T the instance of the pipe.\n */\nfunction pipe(index, pipeName) {\n    var tView = getTView();\n    var pipeDef;\n    if (tView.firstTemplatePass) {\n        pipeDef = getPipeDef(pipeName, tView.pipeRegistry);\n        tView.data[index] = pipeDef;\n        if (pipeDef.onDestroy) {\n            (tView.pipeDestroyHooks || (tView.pipeDestroyHooks = [])).push(index, pipeDef.onDestroy);\n        }\n    }\n    else {\n        pipeDef = tView.data[index];\n    }\n    var pipeInstance = pipeDef.n();\n    store(index, pipeInstance);\n    return pipeInstance;\n}\n/**\n * Searches the pipe registry for a pipe with the given name. If one is found,\n * returns the pipe. Otherwise, an error is thrown because the pipe cannot be resolved.\n *\n * @param name Name of pipe to resolve\n * @param registry Full list of available pipes\n * @returns Matching PipeDef\n */\nfunction getPipeDef(name, registry) {\n    if (registry) {\n        for (var i = 0; i < registry.length; i++) {\n            var pipeDef = registry[i];\n            if (name === pipeDef.name) {\n                return pipeDef;\n            }\n        }\n    }\n    throw new Error(\"Pipe with name '\" + name + \"' not found!\");\n}\n/**\n * Invokes a pipe with 1 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind1(index, v1) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction1(pipeInstance.transform, v1, pipeInstance) :\n        pipeInstance.transform(v1);\n}\n/**\n * Invokes a pipe with 2 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind2(index, v1, v2) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction2(pipeInstance.transform, v1, v2, pipeInstance) :\n        pipeInstance.transform(v1, v2);\n}\n/**\n * Invokes a pipe with 3 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 4rd argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind3(index, v1, v2, v3) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction3(pipeInstance.transform.bind(pipeInstance), v1, v2, v3) :\n        pipeInstance.transform(v1, v2, v3);\n}\n/**\n * Invokes a pipe with 4 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 3rd argument to {@link PipeTransform#transform}.\n * @param v4 4th argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind4(index, v1, v2, v3, v4) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction4(pipeInstance.transform, v1, v2, v3, v4, pipeInstance) :\n        pipeInstance.transform(v1, v2, v3, v4);\n}\n/**\n * Invokes a pipe with variable number of arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param values Array of arguments to pass to {@link PipeTransform#transform} method.\n */\nfunction pipeBindV(index, values) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunctionV(pipeInstance.transform, values, pipeInstance) :\n        pipeInstance.transform.apply(pipeInstance, values);\n}\nfunction isPure(index) {\n    return getTView().data[index].pure;\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar LQueries_ = /** @class */ (function () {\n    function LQueries_(deep) {\n        this.shallow = null;\n        this.deep = null;\n        this.deep = deep == null ? null : deep;\n    }\n    LQueries_.prototype.track = function (queryList, predicate, descend, read) {\n        // TODO(misko): This is not right. In case of inherited state, a calling track will incorrectly\n        // mutate parent.\n        if (descend) {\n            this.deep = createQuery$1(this.deep, queryList, predicate, read != null ? read : null);\n        }\n        else {\n            this.shallow = createQuery$1(this.shallow, queryList, predicate, read != null ? read : null);\n        }\n    };\n    LQueries_.prototype.child = function () {\n        if (this.deep === null) {\n            // if we don't have any deep queries then no need to track anything more.\n            return null;\n        }\n        if (this.shallow === null) {\n            // DeepQuery: We can reuse the current state if the child state would be same as current\n            // state.\n            return this;\n        }\n        else {\n            // We need to create new state\n            return new LQueries_(this.deep);\n        }\n    };\n    LQueries_.prototype.container = function () {\n        var result = null;\n        var query = this.deep;\n        while (query) {\n            var containerValues = []; // prepare room for views\n            query.values.push(containerValues);\n            var clonedQuery = { next: null, list: query.list, predicate: query.predicate, values: containerValues };\n            clonedQuery.next = result;\n            result = clonedQuery;\n            query = query.next;\n        }\n        return result ? new LQueries_(result) : null;\n    };\n    LQueries_.prototype.enterView = function (index) {\n        var result = null;\n        var query = this.deep;\n        while (query) {\n            var viewValues = []; // prepare room for view nodes\n            query.values.splice(index, 0, viewValues);\n            var clonedQuery = { next: null, list: query.list, predicate: query.predicate, values: viewValues };\n            clonedQuery.next = result;\n            result = clonedQuery;\n            query = query.next;\n        }\n        return result ? new LQueries_(result) : null;\n    };\n    LQueries_.prototype.addNode = function (node) {\n        add(this.shallow, node);\n        add(this.deep, node);\n    };\n    LQueries_.prototype.removeView = function (index) {\n        var query = this.deep;\n        while (query) {\n            var removed = query.values.splice(index, 1);\n            // mark a query as dirty only when removed view had matching modes\n            ngDevMode && assertEqual(removed.length, 1, 'removed.length');\n            if (removed[0].length) {\n                query.list.setDirty();\n            }\n            query = query.next;\n        }\n    };\n    return LQueries_;\n}());\n/**\n * Iterates over local names for a given node and returns directive index\n * (or -1 if a local name points to an element).\n *\n * @param tNode static data of a node to check\n * @param selector selector to match\n * @returns directive index, -1 or null if a selector didn't match any of the local names\n */\nfunction getIdxOfMatchingSelector(tNode, selector) {\n    var localNames = tNode.localNames;\n    if (localNames) {\n        for (var i = 0; i < localNames.length; i += 2) {\n            if (localNames[i] === selector) {\n                return localNames[i + 1];\n            }\n        }\n    }\n    return null;\n}\n/**\n * Iterates over all the directives for a node and returns index of a directive for a given type.\n *\n * @param node Node on which directives are present.\n * @param type Type of a directive to look for.\n * @returns Index of a found directive or null when none found.\n */\nfunction getIdxOfMatchingDirective(node, type) {\n    var defs = (node.view.tView.directives);\n    var flags = node.tNode.flags;\n    var count = flags & 4095;\n    var start = flags >> 13;\n    var end = start + count;\n    for (var i = start; i < end; i++) {\n        var def = defs[i];\n        if (def.type === type && def.diPublic) {\n            return i;\n        }\n    }\n    return null;\n}\nfunction readFromNodeInjector(nodeInjector, node, read, directiveIdx) {\n    if (read instanceof ReadFromInjectorFn) {\n        return read.read(nodeInjector, node, directiveIdx);\n    }\n    else {\n        var matchingIdx = getIdxOfMatchingDirective(node, read);\n        if (matchingIdx !== null) {\n            return node.view.directives[matchingIdx];\n        }\n    }\n    return null;\n}\nfunction add(query, node) {\n    var nodeInjector = getOrCreateNodeInjectorForNode(node);\n    while (query) {\n        var predicate = query.predicate;\n        var type = predicate.type;\n        if (type) {\n            var directiveIdx = getIdxOfMatchingDirective(node, type);\n            if (directiveIdx !== null) {\n                // a node is matching a predicate - determine what to read\n                // if read token and / or strategy is not specified, use type as read token\n                var result = readFromNodeInjector(nodeInjector, node, predicate.read || type, directiveIdx);\n                if (result !== null) {\n                    addMatch(query, result);\n                }\n            }\n        }\n        else {\n            var selector = (predicate.selector);\n            for (var i = 0; i < selector.length; i++) {\n                ngDevMode && assertNotNull(node.tNode, 'node.tNode');\n                var directiveIdx = getIdxOfMatchingSelector((node.tNode), selector[i]);\n                if (directiveIdx !== null) {\n                    // a node is matching a predicate - determine what to read\n                    // note that queries using name selector must specify read strategy\n                    ngDevMode && assertNotNull(predicate.read, 'the node should have a predicate');\n                    var result = readFromNodeInjector(nodeInjector, node, (predicate.read), directiveIdx);\n                    if (result !== null) {\n                        addMatch(query, result);\n                    }\n                }\n            }\n        }\n        query = query.next;\n    }\n}\nfunction addMatch(query, matchingValue) {\n    query.values.push(matchingValue);\n    query.list.setDirty();\n}\nfunction createPredicate(predicate, read) {\n    var isArray = Array.isArray(predicate);\n    return {\n        type: isArray ? null : predicate,\n        selector: isArray ? predicate : null,\n        read: read\n    };\n}\nfunction createQuery$1(previous, queryList, predicate, read) {\n    return {\n        next: previous,\n        list: queryList,\n        predicate: createPredicate(predicate, read),\n        values: queryList._valuesTree\n    };\n}\nvar QueryList_ = /** @class */ (function () {\n    function QueryList_() {\n        this.dirty = true;\n        this.changes = new EventEmitter();\n        this._values = [];\n        /** @internal */\n        this._valuesTree = [];\n    }\n    Object.defineProperty(QueryList_.prototype, \"length\", {\n        get: function () { return this._values.length; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QueryList_.prototype, \"first\", {\n        get: function () {\n            var values = this._values;\n            return values.length ? values[0] : null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QueryList_.prototype, \"last\", {\n        get: function () {\n            var values = this._values;\n            return values.length ? values[values.length - 1] : null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * See\n     * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n     */\n    /**\n       * See\n       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n       */\n    QueryList_.prototype.map = /**\n       * See\n       * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n       */\n    function (fn) { return this._values.map(fn); };\n    /**\n     * See\n     * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n     */\n    /**\n       * See\n       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n       */\n    QueryList_.prototype.filter = /**\n       * See\n       * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n       */\n    function (fn) {\n        return this._values.filter(fn);\n    };\n    /**\n     * See\n     * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n     */\n    /**\n       * See\n       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n       */\n    QueryList_.prototype.find = /**\n       * See\n       * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n       */\n    function (fn) {\n        return this._values.find(fn);\n    };\n    /**\n     * See\n     * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n     */\n    /**\n       * See\n       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n       */\n    QueryList_.prototype.reduce = /**\n       * See\n       * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n       */\n    function (fn, init) {\n        return this._values.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     */\n    /**\n       * See\n       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n       */\n    QueryList_.prototype.forEach = /**\n       * See\n       * [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)\n       */\n    function (fn) { this._values.forEach(fn); };\n    /**\n     * See\n     * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n     */\n    /**\n       * See\n       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n       */\n    QueryList_.prototype.some = /**\n       * See\n       * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n       */\n    function (fn) {\n        return this._values.some(fn);\n    };\n    QueryList_.prototype.toArray = function () { return this._values.slice(0); };\n    QueryList_.prototype[getSymbolIterator()] = function () { return this._values[getSymbolIterator()](); };\n    QueryList_.prototype.toString = function () { return this._values.toString(); };\n    QueryList_.prototype.reset = function (res) {\n        this._values = flatten$1(res);\n        this.dirty = false;\n    };\n    QueryList_.prototype.notifyOnChanges = function () { this.changes.emit(this); };\n    QueryList_.prototype.setDirty = function () { this.dirty = true; };\n    QueryList_.prototype.destroy = function () {\n        this.changes.complete();\n        this.changes.unsubscribe();\n    };\n    return QueryList_;\n}());\nvar QueryList$1 = QueryList_;\n/**\n * Creates and returns a QueryList.\n *\n * @param memoryIndex The index in memory where the QueryList should be saved. If null,\n * this is is a content query and the QueryList will be saved later through directiveCreate.\n * @param predicate The type for which the query will search\n * @param descend Whether or not to descend into children\n * @param read What to save in the query\n * @returns QueryList<T>\n */\nfunction query(memoryIndex, predicate, descend, read) {\n    ngDevMode && assertPreviousIsParent();\n    var queryList = new QueryList$1();\n    var queries = getCurrentQueries(LQueries_);\n    queries.track(queryList, predicate, descend, read);\n    if (memoryIndex != null) {\n        store(memoryIndex, queryList);\n    }\n    return queryList;\n}\n/**\n * Refreshes a query by combining matches from all active views and removing matches from deleted\n * views.\n * Returns true if a query got dirty during change detection, false otherwise.\n */\nfunction queryRefresh(queryList) {\n    var queryListImpl = queryList;\n    if (queryList.dirty) {\n        queryList.reset(queryListImpl._valuesTree);\n        queryList.notifyOnChanges();\n        return true;\n    }\n    return false;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar BRAND = '__SANITIZER_TRUSTED_BRAND__';\n/**\n * An `html` sanitizer which converts untrusted `html` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `html` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustHtml}.\n *\n * @param unsafeHtml untrusted `html`, typically from the user.\n * @returns `html` string which is safe to display to user, because all of the dangerous javascript\n * and urls have been removed.\n */\nfunction sanitizeHtml(unsafeHtml) {\n    if (unsafeHtml instanceof String && unsafeHtml[BRAND] === 'Html') {\n        return unsafeHtml.toString();\n    }\n    return _sanitizeHtml(document, stringify$1(unsafeHtml));\n}\n/**\n * A `style` sanitizer which converts untrusted `style` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `style` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustStyle}.\n *\n * @param unsafeStyle untrusted `style`, typically from the user.\n * @returns `style` string which is safe to bind to the `style` properties, because all of the\n * dangerous javascript and urls have been removed.\n */\nfunction sanitizeStyle(unsafeStyle) {\n    if (unsafeStyle instanceof String && unsafeStyle[BRAND] === 'Style') {\n        return unsafeStyle.toString();\n    }\n    return _sanitizeStyle(stringify$1(unsafeStyle));\n}\n/**\n * A `url` sanitizer which converts untrusted `url` **string** into trusted string by removing\n * dangerous\n * content.\n *\n * This method parses the `url` and locates potentially dangerous content (such as javascript) and\n * removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustUrl}.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * all of the dangerous javascript has been removed.\n */\nfunction sanitizeUrl(unsafeUrl) {\n    if (unsafeUrl instanceof String && unsafeUrl[BRAND] === 'Url') {\n        return unsafeUrl.toString();\n    }\n    return _sanitizeUrl(stringify$1(unsafeUrl));\n}\n/**\n * A `url` sanitizer which only lets trusted `url`s through.\n *\n * This passes only `url`s marked trusted by calling {@link bypassSanitizationTrustResourceUrl}.\n *\n * @param unsafeResourceUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * only trusted `url`s have been allowed to pass.\n */\nfunction sanitizeResourceUrl(unsafeResourceUrl) {\n    if (unsafeResourceUrl instanceof String &&\n        unsafeResourceUrl[BRAND] === 'ResourceUrl') {\n        return unsafeResourceUrl.toString();\n    }\n    throw new Error('unsafe value used in a resource URL context (see http://g.co/ng/security#xss)');\n}\n/**\n * A `script` sanitizer which only lets trusted javascript through.\n *\n * This passes only `script`s marked trusted by calling {@link bypassSanitizationTrustScript}.\n *\n * @param unsafeScript untrusted `script`, typically from the user.\n * @returns `url` string which is safe to bind to the `<script>` element such as `<img src>`,\n * because only trusted `scripts`s have been allowed to pass.\n */\n\n/**\n * Mark `html` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link htmlSanitizer} to be trusted implicitly.\n *\n * @param trustedHtml `html` string which needs to be implicitly trusted.\n * @returns a `html` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustHtml(trustedHtml) {\n    return bypassSanitizationTrustString(trustedHtml, 'Html');\n}\n/**\n * Mark `style` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link styleSanitizer} to be trusted implicitly.\n *\n * @param trustedStyle `style` string which needs to be implicitly trusted.\n * @returns a `style` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustStyle(trustedStyle) {\n    return bypassSanitizationTrustString(trustedStyle, 'Style');\n}\n/**\n * Mark `script` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link scriptSanitizer} to be trusted implicitly.\n *\n * @param trustedScript `script` string which needs to be implicitly trusted.\n * @returns a `script` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustScript(trustedScript) {\n    return bypassSanitizationTrustString(trustedScript, 'Script');\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link urlSanitizer} to be trusted implicitly.\n *\n * @param trustedUrl `url` string which needs to be implicitly trusted.\n * @returns a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustUrl(trustedUrl) {\n    return bypassSanitizationTrustString(trustedUrl, 'Url');\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link resourceUrlSanitizer} to be trusted implicitly.\n *\n * @param trustedResourceUrl `url` string which needs to be implicitly trusted.\n * @returns a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustResourceUrl(trustedResourceUrl) {\n    return bypassSanitizationTrustString(trustedResourceUrl, 'ResourceUrl');\n}\nfunction bypassSanitizationTrustString(trustedString, mode) {\n    var trusted = new String(trustedString);\n    trusted[BRAND] = mode;\n    return trusted;\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// clang-format on\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// This file only reexports content of the `src` folder. Keep it that way.\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexports.ɵangular_packages_core_core_j = _iterableDiffersFactory;\nexports.ɵangular_packages_core_core_k = _keyValueDiffersFactory;\nexports.ɵangular_packages_core_core_l = _localeFactory;\nexports.ɵangular_packages_core_core_f = _appIdRandomProviderFactory;\nexports.ɵangular_packages_core_core_g = defaultKeyValueDiffers;\nexports.ɵangular_packages_core_core_h = DefaultIterableDifferFactory;\nexports.ɵangular_packages_core_core_i = DefaultKeyValueDifferFactory;\nexports.ɵangular_packages_core_core_c = ReflectiveInjector_;\nexports.ɵangular_packages_core_core_d = ReflectiveDependency;\nexports.ɵangular_packages_core_core_e = resolveReflectiveProviders;\nexports.ɵangular_packages_core_core_m = wtfEnabled;\nexports.ɵangular_packages_core_core_o = createScope;\nexports.ɵangular_packages_core_core_n = detectWTF;\nexports.ɵangular_packages_core_core_r = endTimeRange;\nexports.ɵangular_packages_core_core_p = leave;\nexports.ɵangular_packages_core_core_q = startTimeRange;\nexports.ɵangular_packages_core_core_v = getOrCreateChangeDetectorRef;\nexports.ɵangular_packages_core_core_x = getOrCreateContainerRef;\nexports.ɵangular_packages_core_core_w = getOrCreateInjectable;\nexports.ɵangular_packages_core_core_u = getOrCreateNodeInjector;\nexports.ɵangular_packages_core_core_y = getOrCreateTemplateRef;\nexports.ɵangular_packages_core_core_bb = bindingUpdated;\nexports.ɵangular_packages_core_core_bd = bindingUpdated2;\nexports.ɵangular_packages_core_core_be = bindingUpdated4;\nexports.ɵangular_packages_core_core_bc = checkAndUpdateBinding$1;\nexports.ɵangular_packages_core_core_ba = consumeBinding;\nexports.ɵangular_packages_core_core_z = getCreationMode;\nexports.ɵangular_packages_core_core_a = makeParamDecorator;\nexports.ɵangular_packages_core_core_b = makePropDecorator;\nexports.ɵangular_packages_core_core_s = _def;\nexports.ɵangular_packages_core_core_t = DebugContext;\nexports.createPlatform = createPlatform;\nexports.assertPlatform = assertPlatform;\nexports.destroyPlatform = destroyPlatform;\nexports.getPlatform = getPlatform;\nexports.PlatformRef = PlatformRef;\nexports.ApplicationRef = ApplicationRef;\nexports.enableProdMode = enableProdMode;\nexports.isDevMode = isDevMode;\nexports.createPlatformFactory = createPlatformFactory;\nexports.NgProbeToken = NgProbeToken;\nexports.APP_ID = APP_ID;\nexports.PACKAGE_ROOT_URL = PACKAGE_ROOT_URL;\nexports.PLATFORM_INITIALIZER = PLATFORM_INITIALIZER;\nexports.PLATFORM_ID = PLATFORM_ID;\nexports.APP_BOOTSTRAP_LISTENER = APP_BOOTSTRAP_LISTENER;\nexports.APP_INITIALIZER = APP_INITIALIZER;\nexports.ApplicationInitStatus = ApplicationInitStatus;\nexports.DebugElement = DebugElement;\nexports.DebugNode = DebugNode;\nexports.asNativeElements = asNativeElements;\nexports.getDebugNode = getDebugNode;\nexports.Testability = Testability;\nexports.TestabilityRegistry = TestabilityRegistry;\nexports.setTestabilityGetter = setTestabilityGetter;\nexports.TRANSLATIONS = TRANSLATIONS;\nexports.TRANSLATIONS_FORMAT = TRANSLATIONS_FORMAT;\nexports.LOCALE_ID = LOCALE_ID;\nexports.ApplicationModule = ApplicationModule;\nexports.wtfCreateScope = wtfCreateScope;\nexports.wtfLeave = wtfLeave;\nexports.wtfStartTimeRange = wtfStartTimeRange;\nexports.wtfEndTimeRange = wtfEndTimeRange;\nexports.Type = Type;\nexports.EventEmitter = EventEmitter;\nexports.ErrorHandler = ErrorHandler;\nexports.Sanitizer = Sanitizer;\nexports.ANALYZE_FOR_ENTRY_COMPONENTS = ANALYZE_FOR_ENTRY_COMPONENTS;\nexports.Attribute = Attribute;\nexports.ContentChild = ContentChild;\nexports.ContentChildren = ContentChildren;\nexports.Query = Query;\nexports.ViewChild = ViewChild;\nexports.ViewChildren = ViewChildren;\nexports.Component = Component;\nexports.Directive = Directive;\nexports.HostBinding = HostBinding;\nexports.HostListener = HostListener;\nexports.Input = Input;\nexports.Output = Output;\nexports.Pipe = Pipe;\nexports.CUSTOM_ELEMENTS_SCHEMA = CUSTOM_ELEMENTS_SCHEMA;\nexports.NO_ERRORS_SCHEMA = NO_ERRORS_SCHEMA;\nexports.NgModule = NgModule;\nexports.Version = Version;\nexports.VERSION = VERSION;\nexports.defineInjectable = defineInjectable;\nexports.defineInjector = defineInjector;\nexports.forwardRef = forwardRef;\nexports.resolveForwardRef = resolveForwardRef;\nexports.Injectable = Injectable;\nexports.inject = inject;\nexports.INJECTOR = INJECTOR;\nexports.Injector = Injector;\nexports.ReflectiveInjector = ReflectiveInjector;\nexports.createInjector = createInjector;\nexports.ResolvedReflectiveFactory = ResolvedReflectiveFactory;\nexports.ReflectiveKey = ReflectiveKey;\nexports.InjectionToken = InjectionToken;\nexports.Inject = Inject;\nexports.Optional = Optional;\nexports.Self = Self;\nexports.SkipSelf = SkipSelf;\nexports.Host = Host;\nexports.NgZone = NgZone;\nexports.RenderComponentType = RenderComponentType;\nexports.Renderer = Renderer;\nexports.Renderer2 = Renderer2;\nexports.RendererFactory2 = RendererFactory2;\nexports.RootRenderer = RootRenderer;\nexports.COMPILER_OPTIONS = COMPILER_OPTIONS;\nexports.Compiler = Compiler;\nexports.CompilerFactory = CompilerFactory;\nexports.ModuleWithComponentFactories = ModuleWithComponentFactories;\nexports.ComponentFactory = ComponentFactory;\nexports.ComponentRef = ComponentRef;\nexports.ComponentFactoryResolver = ComponentFactoryResolver;\nexports.ElementRef = ElementRef;\nexports.NgModuleFactory = NgModuleFactory;\nexports.NgModuleRef = NgModuleRef;\nexports.NgModuleFactoryLoader = NgModuleFactoryLoader;\nexports.getModuleFactory = getModuleFactory;\nexports.QueryList = QueryList;\nexports.SystemJsNgModuleLoader = SystemJsNgModuleLoader;\nexports.SystemJsNgModuleLoaderConfig = SystemJsNgModuleLoaderConfig;\nexports.TemplateRef = TemplateRef;\nexports.ViewContainerRef = ViewContainerRef;\nexports.EmbeddedViewRef = EmbeddedViewRef;\nexports.ViewRef = ViewRef;\nexports.ChangeDetectorRef = ChangeDetectorRef;\nexports.DefaultIterableDiffer = DefaultIterableDiffer;\nexports.IterableDiffers = IterableDiffers;\nexports.KeyValueDiffers = KeyValueDiffers;\nexports.SimpleChange = SimpleChange;\nexports.WrappedValue = WrappedValue;\nexports.platformCore = platformCore;\nexports.ɵALLOW_MULTIPLE_PLATFORMS = ALLOW_MULTIPLE_PLATFORMS;\nexports.ɵAPP_ID_RANDOM_PROVIDER = APP_ID_RANDOM_PROVIDER;\nexports.ɵdefaultIterableDiffers = defaultIterableDiffers;\nexports.ɵdevModeEqual = devModeEqual;\nexports.ɵisListLikeIterable = isListLikeIterable;\nexports.ɵisDefaultChangeDetectionStrategy = isDefaultChangeDetectionStrategy;\nexports.ɵConsole = Console;\nexports.ɵinject = inject;\nexports.ɵsetCurrentInjector = setCurrentInjector;\nexports.ɵAPP_ROOT = APP_ROOT;\nexports.ɵComponentFactory = ComponentFactory;\nexports.ɵCodegenComponentFactoryResolver = CodegenComponentFactoryResolver;\nexports.ɵReflectionCapabilities = ReflectionCapabilities;\nexports.ɵRenderDebugInfo = RenderDebugInfo;\nexports.ɵ_sanitizeHtml = _sanitizeHtml;\nexports.ɵ_sanitizeStyle = _sanitizeStyle;\nexports.ɵ_sanitizeUrl = _sanitizeUrl;\nexports.ɵglobal = _global;\nexports.ɵlooseIdentical = looseIdentical;\nexports.ɵstringify = stringify;\nexports.ɵmakeDecorator = makeDecorator;\nexports.ɵisObservable = isObservable;\nexports.ɵisPromise = isPromise;\nexports.ɵclearOverrides = clearOverrides;\nexports.ɵoverrideComponentView = overrideComponentView;\nexports.ɵoverrideProvider = overrideProvider;\nexports.ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR;\nexports.ɵdefineComponent = defineComponent;\nexports.ɵdefineDirective = defineDirective;\nexports.ɵdefinePipe = definePipe;\nexports.ɵdetectChanges = detectChanges;\nexports.ɵrenderComponent = renderComponent;\nexports.ɵdirectiveInject = directiveInject;\nexports.ɵinjectTemplateRef = injectTemplateRef;\nexports.ɵinjectViewContainerRef = injectViewContainerRef;\nexports.ɵinjectChangeDetectorRef = injectChangeDetectorRef;\nexports.ɵinjectAttribute = injectAttribute;\nexports.ɵPublicFeature = PublicFeature;\nexports.ɵNgOnChangesFeature = NgOnChangesFeature;\nexports.ɵmarkDirty = markDirty;\nexports.ɵNC = NO_CHANGE;\nexports.ɵC = container;\nexports.ɵE = elementStart;\nexports.ɵL = listener;\nexports.ɵT = text;\nexports.ɵV = embeddedViewStart;\nexports.ɵQ = query;\nexports.ɵd = loadDirective;\nexports.ɵP = projection;\nexports.ɵb = bind;\nexports.ɵi1 = interpolation1;\nexports.ɵi2 = interpolation2;\nexports.ɵi3 = interpolation3;\nexports.ɵi4 = interpolation4;\nexports.ɵi5 = interpolation5;\nexports.ɵi6 = interpolation6;\nexports.ɵi7 = interpolation7;\nexports.ɵi8 = interpolation8;\nexports.ɵiV = interpolationV;\nexports.ɵpb1 = pipeBind1;\nexports.ɵpb2 = pipeBind2;\nexports.ɵpb3 = pipeBind3;\nexports.ɵpb4 = pipeBind4;\nexports.ɵpbV = pipeBindV;\nexports.ɵf0 = pureFunction0;\nexports.ɵf1 = pureFunction1;\nexports.ɵf2 = pureFunction2;\nexports.ɵf3 = pureFunction3;\nexports.ɵf4 = pureFunction4;\nexports.ɵf5 = pureFunction5;\nexports.ɵf6 = pureFunction6;\nexports.ɵf7 = pureFunction7;\nexports.ɵf8 = pureFunction8;\nexports.ɵfV = pureFunctionV;\nexports.ɵcR = containerRefreshStart;\nexports.ɵcr = containerRefreshEnd;\nexports.ɵqR = queryRefresh;\nexports.ɵe = elementEnd;\nexports.ɵp = elementProperty;\nexports.ɵpD = projectionDef;\nexports.ɵa = elementAttribute;\nexports.ɵs = elementStyle;\nexports.ɵsn = elementStyleNamed;\nexports.ɵk = elementClass;\nexports.ɵkn = elementClassNamed;\nexports.ɵt = textBinding;\nexports.ɵv = embeddedViewEnd;\nexports.ɵst = store;\nexports.ɵld = load;\nexports.ɵPp = pipe;\nexports.ɵwhenRendered = whenRendered;\nexports.ɵbypassSanitizationTrustHtml = bypassSanitizationTrustHtml;\nexports.ɵbypassSanitizationTrustStyle = bypassSanitizationTrustStyle;\nexports.ɵbypassSanitizationTrustScript = bypassSanitizationTrustScript;\nexports.ɵbypassSanitizationTrustUrl = bypassSanitizationTrustUrl;\nexports.ɵbypassSanitizationTrustResourceUrl = bypassSanitizationTrustResourceUrl;\nexports.ɵsanitizeHtml = sanitizeHtml;\nexports.ɵsanitizeStyle = sanitizeStyle;\nexports.ɵsanitizeUrl = sanitizeUrl;\nexports.ɵsanitizeResourceUrl = sanitizeResourceUrl;\nexports.ɵregisterModuleFactory = registerModuleFactory;\nexports.ɵEMPTY_ARRAY = EMPTY_ARRAY$2;\nexports.ɵEMPTY_MAP = EMPTY_MAP;\nexports.ɵand = anchorDef;\nexports.ɵccf = createComponentFactory;\nexports.ɵcmf = createNgModuleFactory;\nexports.ɵcrt = createRendererType2;\nexports.ɵdid = directiveDef;\nexports.ɵeld = elementDef;\nexports.ɵelementEventFullName = elementEventFullName;\nexports.ɵgetComponentViewDefinitionFactory = getComponentViewDefinitionFactory;\nexports.ɵinlineInterpolate = inlineInterpolate;\nexports.ɵinterpolate = interpolate;\nexports.ɵmod = moduleDef;\nexports.ɵmpd = moduleProvideDef;\nexports.ɵncd = ngContentDef;\nexports.ɵnov = nodeValue;\nexports.ɵpid = pipeDef;\nexports.ɵprd = providerDef;\nexports.ɵpad = pureArrayDef;\nexports.ɵpod = pureObjectDef;\nexports.ɵppd = purePipeDef;\nexports.ɵqud = queryDef;\nexports.ɵted = textDef;\nexports.ɵunv = unwrapValue;\nexports.ɵvid = viewDef;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=core.umd.js.map\n"]}
+{"version":3,"sources":["packages/core/core.umd.js"],"names":["global","factory","exports","module","require","define","amd","ng","core","rxjs","operators","this","extendStatics","Object","setPrototypeOf","__proto__","Array","d","b","p","hasOwnProperty","__extends","__","constructor","prototype","create","__assign","assign","t","s","i","n","arguments","length","call","__values","o","m","Symbol","iterator","next","value","done","__read","r","e","ar","push","error","__spread","concat","defineInjectable","opts","providedIn","undefined","defineInjector","options","providers","imports","InjectionToken","_desc","ngMetadataName","ngInjectableDef","toString","ANNOTATIONS","PARAMETERS","PROP_METADATA","makeDecorator","name","props","parentClass","chainFn","typeFn","metaCtor","makeMetadataCtor","DecoratorFactory","args","_i","apply","_a","annotationInstance","bind","TypeDecorator","cls","defineProperty","annotationCls","ctor","values","propName","makeParamDecorator","ParamDecoratorFactory","ParamDecorator","annotation","unusedKey","index","parameters","makePropDecorator","PropDecoratorFactory","decoratorInstance","PropDecorator","target","meta","unshift","ChangeDetectionStrategy","ChangeDetectorStatus","Query","ANALYZE_FOR_ENTRY_COMPONENTS","Attribute","attributeName","ContentChildren","selector","data","first","isViewQuery","descendants","ContentChild","ViewChildren","ViewChild","ɵChangeDetectorStatus","Directive","dir","Component","c","changeDetection","Default","Pipe","pure","Input","bindingPropertyName","Output","HostBinding","hostPropertyName","HostListener","eventName","Type","Function","isType","v","__window","window","__self","self","WorkerGlobalScope","__global","_global","promise","Promise","resolve","_symbolIterator","getSymbolIterator","Symbol_1","keys","getOwnPropertyNames","Map","key","scheduleMicroTask","fn","Zone","then","current","looseIdentical","a","isNaN","stringify","token","map","join","overriddenName","res","newLineIndex","indexOf","substring","DELEGATE_CTOR","INHERITED_CLASS","INHERITED_CLASS_WITH_CTOR","ReflectionCapabilities","reflect","_reflect","isReflectionEnabled","_zipTypesAndAnnotations","paramTypes","paramAnnotations","result","_ownParameters","type","parentCtor","typeStr","exec","tsickleCtorParams","ctorParameters","paramTypes_1","ctorParam","paramAnnotations_1","convertTsickleDecoratorIntoMetadata","decorators","getOwnMetadata","fill","getParentCtor","_ownAnnotations","typeOrFunc","annotations","ownAnnotations","_ownPropMetadata","propMetadata","propDecorators","propDecorators_1","propMetadata_1","forEach","prop","parentPropMetadata_1","ownPropMetadata","hasLifecycleHook","lcProperty","guards","getter","setter","method","importUri","resourceUri","resolveIdentifier","moduleUrl","members","runtime","resolveEnum","enumIdentifier","decoratorInvocations","decoratorInvocation","parentProto","getPrototypeOf","forwardRef","forwardRefFn","__forward_ref__","resolveForwardRef","Inject","Optional","Self","SkipSelf","Host","SOURCE","_THROW_IF_NOT_FOUND","THROW_IF_NOT_FOUND","INJECTOR","NullInjector","get","notFoundValue","Error","Injector","parent","isArray","StaticInjector","NULL","inject","IDENT","EMPTY","CIRCULAR","MULTI_PROVIDER_FN","slice","GET_PROPERTY_NAME$1","USE_VALUE$1","getClosureSafeProperty$1","objWithPropertyToExtract","provide","String","useValue","NULL_INJECTOR","NEW_LINE","NO_NEW_LINE","source","records","_records","set","deps","useNew","recursivelyProcessProviders","provider","staticError","resolvedProvider","resolveProvider","computeDeps","providerDeps","j","useExisting","useFactory","useClass","multi","multiProvider","multiProviderMixError","record","flags","tryResolveToken","resolveToken","depRecords","depRecord","childRecord","tokenPath","message","formatError","tokens","text","obj","charAt","substr","context","parts","JSON","replace","_currentInjector","setCurrentInjector","injector","former","injectableDef","injectArgs","types","arg","GET_PROPERTY_NAME","USE_VALUE","getClosureSafeProperty","EMPTY_ARRAY","convertInjectableProviderToFactory","deps_1","reflectionCapabilities","valueProvider_1","existingProvider_1","factoryProvider_1","classProvider_1","deps_2","deps_3","ViewEncapsulation","Injectable","injectableType","NgModule","ngModule","moduleType","metadata","ngInjectorDef","Version","VERSION","full","major","split","minor","patch","ERROR_DEBUG_CONTEXT","ERROR_ORIGINAL_ERROR","ERROR_LOGGER","getDebugContext","getOriginalError","defaultErrorLogger","console","ErrorHandler","_console","handleError","originalError","_findOriginalError","_findContext","errorLogger","getErrorLogger","constructResolvingPath","findFirstClosedCycle","reverse","k","injectionError","constructResolvingMessage","errMsg","wrappedError","msg","addKey","injectors","noAnnotationError","params","signature","ii","parameter","ReflectiveKey","id","displayName","_globalKeyRegistry","numberOfKeys","enumerable","configurable","KeyRegistry","_allKeys","has","newKey","size","reflector","Reflector","updateCapabilities","caps","identifier","ReflectiveDependency","optional","visibility","fromKey","_EMPTY_LIST","ResolvedReflectiveProvider_","resolvedFactories","resolvedFactory","ResolvedReflectiveFactory","dependencies","resolveReflectiveProvider","resolveReflectiveFactory","factoryFn","resolvedDeps","_dependenciesFor","aliasInstance","constructDependencies","params_1","_extractToken","resolveReflectiveProviders","resolvedProviderMap","mergeResolvedReflectiveProviders","normalizedProvidersMap","existing","_normalizeProviders","invalidProviderError","from","some","_createDependency","paramMetadata","UNDEFINED","ReflectiveInjector","resolveAndCreate","ResolvedReflectiveProviders","fromResolvedProviders","ReflectiveInjector_","_providers","_parent","_constructionCounter","len","keyIds","objs","_getByKey","resolveAndCreateChild","createChildFromResolved","inj","resolveAndInstantiate","instantiateResolved","_instantiateProvider","getProviderAtIndex","outOfBoundsError","_new","_getMaxNumberOfObjects","cyclicDependencyError","_instantiate","ResolvedReflectiveFactory$$1","_this","dep","_getByReflectiveDependency","instantiationError","originalException","originalStack","INJECTOR_KEY","_getByKeySelf","_getByKeyDefault","_getObjByKeyId","keyId","_throwOrNull","noProviderError","inj_","_mapProviders","APP_ROOT","NOT_YET","CIRCULAR$1","EMPTY_ARRAY$1","NULL_INJECTOR$1","getNullInjector","R3Injector","def","injectorDefTypes","Set","onDestroy","destroyed","deepForEach","injectorDef","processInjectorType","makeRecord","isRootInjector","defType","destroy","assertNotDestroyed","service","ngOnDestroy","clear","previousInjector","couldBeInjectableType","injectableDefInScope","injectableDefRecord","hydrate","defOrWrappedDef","parents","add","imported","delete","processProvider","isTypeProvider","providerToRecord","isValueProvider","isExistingProvider","isFactoryProvider","classRef_1","hasDeps","multiRecord_1","hasOnDestroy","input","isPromise","APP_INITIALIZER","ApplicationInitStatus","appInits","initialized","donePromise","rej","reject","runInitializers","asyncInitPromises","complete","initResult","all","catch","APP_ID","_appIdRandomProviderFactory","_randomChar","APP_ID_RANDOM_PROVIDER","fromCharCode","Math","floor","random","PLATFORM_INITIALIZER","PLATFORM_ID","APP_BOOTSTRAP_LISTENER","PACKAGE_ROOT_URL","Console","log","warn","ModuleWithComponentFactories","ngModuleFactory","componentFactories","_throwError","Compiler","compileModuleSync","compileModuleAsync","compileModuleAndAllComponentsSync","compileModuleAndAllComponentsAsync","clearCache","clearCacheFor","COMPILER_OPTIONS","CompilerFactory","ComponentRef","ComponentFactory","noComponentFactoryError","component","ERROR_COMPONENT","trace","events","_NullComponentFactoryResolver","resolveComponentFactory","ComponentFactoryResolver","CodegenComponentFactoryResolver","factories","_ngModule","_factories","componentType","ComponentFactoryBoundToModule","_super","ngContentSelectors","inputs","outputs","projectableNodes","rootSelectorOrNode","NgModuleRef","NgModuleFactory","detectWTF","wtf","createScope","leave","scope","returnValue","leaveScope","startTimeRange","rangeType","action","beginTimeRange","endTimeRange","range","wtfEnabled","noopScope","arg0","arg1","wtfCreateScope","wtfLeave","wtfStartTimeRange","wtfEndTimeRange","EventEmitter","isAsync","__isAsync","emit","subscribe","generatorOrNext","schedulerFn","errorFn","err","completeFn","setTimeout","sink","Subscription","Subject","NgZone","_b","enableLongStackTrace","hasPendingMicrotasks","hasPendingMacrotasks","isStable","onUnstable","onMicrotaskEmpty","onStable","onError","assertZonePatched","_nesting","_outer","_inner","fork","forkInnerZoneWithAngularBehavior","zone","properties","isAngularZone","onInvokeTask","delegate","task","applyThis","applyArgs","onEnter","invokeTask","onLeave","onInvoke","callback","invoke","onHasTask","hasTaskState","hasTask","change","microTask","checkStable","macroTask","onHandleError","runOutsideAngular","isInAngularZone","assertInAngularZone","assertNotInAngularZone","run","runTask","scheduleEventTask","EMPTY_PAYLOAD","noop","cancelTask","runGuarded","_platform","NoopNgZone","Testability","_ngZone","_pendingCount","_isZoneStable","_didWork","_callbacks","_watchAngularEvents","taskTrackingZone","_runCallbacksIfReady","increasePendingRequestCount","decreasePendingRequestCount","cb","pop","clearTimeout","timeoutId","doneCb","pending_1","getPendingTasks","filter","updateCb","macroTasks","isPeriodic","delay","creationLocation","xhr","addCallback","timeout","whenStable","getPendingRequestCount","findProviders","using","exactMatch","TestabilityRegistry","_applications","_testabilityGetter","addToWindow","registerApplication","testability","unregisterApplication","unregisterAllApplications","getTestability","elem","getAllTestabilities","getAllRootElements","findTestabilityInTree","findInAncestors","_NoopGetTestability","registry","_devMode","_runModeLocked","ALLOW_MULTIPLE_PLATFORMS","isDevMode","NgProbeToken","createPlatform","PlatformRef","inits","init","createPlatformFactory","parentPlatformFactory","desc","marker","extraProviders","platform","getPlatform","injectedProviders","assertPlatform","requiredToken","_injector","_modules","_destroyListeners","_destroyed","bootstrapModuleFactory","moduleFactory","ngZone","getNgZone","ngZoneOption","ngZoneInjector","moduleRef","exceptionHandler","remove","_callAndReportToErrorHandler","errorHandler","initStatus","_moduleDoBootstrap","bootstrapModule","compilerOptions","compilerFactory","optionsReducer","createCompiler","appRef","ApplicationRef","_bootstrapComponents","f","bootstrap","instance","ngDoBootstrap","listener","dst","reduce","_zone","_exceptionHandler","_componentFactoryResolver","_initStatus","_bootstrapListeners","_views","_runningTick","_enforceNoNewChanges","_stable","componentTypes","components","tick","isCurrentlyStable","Observable","observer","stableSub","unstableSub","unsubscribe","merge","pipe","share","componentOrFactory","componentFactory","compRef","_unloadComponent","location","nativeElement","_loadComponent","_tickScope","view","detectChanges","checkNoChanges","attachView","viewRef","attachToAppRef","detachView","detachFromAppRef","componentRef","hostView","list","el","splice","RendererStyleFlags2","RenderComponentType","templateUrl","slotCount","encapsulation","styles","animations","RenderDebugInfo","Renderer","RootRenderer","RendererFactory2","Renderer2","ElementRef","NgModuleFactoryLoader","moduleFactories","QueryList","dirty","_results","changes","find","toArray","reset","flatten","flat","item","flatItem","last","notifyOnChanges","setDirty","SystemJsNgModuleLoaderConfig","DEFAULT_CONFIG","factoryPathPrefix","factoryPathSuffix","SystemJsNgModuleLoader","_compiler","config","_config","load","path","loadFactory","loadAndCompile","exportName","System","import","checkNotEmpty","factoryClassSuffix","modulePath","ChangeDetectorRef","TemplateRef","ViewContainerRef","ViewRef","EmbeddedViewRef","EventListener","DebugNode","nativeNode","_debugContext","DebugElement","addChild","listeners","references","providerTokens","attributes","classes","childNodes","child","removeChild","childIndex","insertChildrenAfter","newChildren","siblingIndex","insertBefore","refChild","newChild","refIndex","query","predicate","queryAll","matches","_queryElementChildren","queryAllNodes","_queryNodeChildren","node","triggerEventHandler","eventObj","element","parentNode","_nativeNodeToDebugNode","getDebugNode","indexDebugNode","devModeEqual","isListLikeIterableA","isListLikeIterable","isListLikeIterableB","areIterablesEqual","comparator","iterator1","iterator2","item1","item2","WrappedValue","wrapped","wrap","unwrap","isWrapped","SimpleChange","previousValue","currentValue","firstChange","isFirstChange","isJsObject","DefaultIterableDifferFactory","supports","trackByFn","DefaultIterableDiffer","trackByIdentity","_linkedRecords","_unlinkedRecords","_previousItHead","_itHead","_itTail","_additionsHead","_additionsTail","_movesHead","_movesTail","_removalsHead","_removalsTail","_identityChangesHead","_identityChangesTail","_trackByFn","forEachItem","_next","forEachOperation","nextIt","nextRemove","addRemoveOffset","moveOffsets","currentIndex","getPreviousIndex","adjPreviousIndex","_nextRemoved","previousIndex","localMovePreviousIndex","localCurrentIndex","offset","forEachPreviousItem","_nextPrevious","forEachAddedItem","_nextAdded","forEachMovedItem","_nextMoved","forEachRemovedItem","forEachIdentityChange","_nextIdentityChange","diff","collection","check","_reset","itemTrackBy","mayBeDirty","index_1","trackById","_verifyReinsertion","_addIdentityChange","_mismatch","iterateListLike","_truncate","isDirty","nextRecord","previousRecord","_prev","_remove","_moveAfter","_reinsertAfter","_addAfter","IterableChangeRecord_","reinsertRecord","_addToMoves","_addToRemovals","_unlink","prevRecord","prev","_prevRemoved","_insertAfter","_DuplicateMap","put","toIndex","_prevDup","_nextDup","_DuplicateItemRecordList","_head","_tail","atOrAfterIndex","duplicates","recordList","moveOffset","MissingTranslationStrategy","DefaultKeyValueDifferFactory","DefaultKeyValueDiffer","_mapHead","_appendAfter","_previousMapHead","_changesHead","_changesTail","forEachChangedItem","_nextChanged","_forEach","_maybeAddToChanges","_getOrCreateRecordForKey","_insertBeforeOrAppend","before","record_1","KeyValueChangeRecord_","_addToAdditions","newValue","_addToChanges","IterableDiffers","copied","extend","iterable","getTypeNameForDebugging","KeyValueDiffers","kv","keyValDiff","iterableDiff","defaultIterableDiffers","defaultKeyValueDiffers","platformCore","LOCALE_ID","TRANSLATIONS","TRANSLATIONS_FORMAT","_iterableDiffersFactory","_keyValueDiffersFactory","_localeFactory","locale","ApplicationModule","InertBodyHelper","defaultDoc","inertDocument","implementation","createHTMLDocument","inertBodyElement","body","inertHtml","createElement","appendChild","innerHTML","querySelector","getInertBodyElement","isDOMParserAvailable","DOMParser","getInertBodyElement_DOMParser","getInertBodyElement_InertDocument","getInertBodyElement_XHR","html","encodeURI","XMLHttpRequest","responseType","open","send","response","firstChild","parseFromString","templateEl","documentMode","stripCustomNsAttrs","elAttrs","attrName","removeAttribute","childNode","nodeType","Node","ELEMENT_NODE","nextSibling","SAFE_URL_PATTERN","DATA_URL_PATTERN","_sanitizeUrl","url","match","tagSet","tags","e_1","_c","e_1_1","return","merge$1","sets","e_2","sets_1","sets_1_1","e_2_1","inertBodyHelper","VOID_ELEMENTS","OPTIONAL_END_TAG_BLOCK_ELEMENTS","OPTIONAL_END_TAG_INLINE_ELEMENTS","OPTIONAL_END_TAG_ELEMENTS","BLOCK_ELEMENTS","INLINE_ELEMENTS","VALID_ELEMENTS","URI_ATTRS","SRCSET_ATTRS","HTML_ATTRS","VALID_ATTRS","SanitizingHtmlSerializer","sanitizedSomething","buf","sanitizeChildren","startElement","TEXT_NODE","chars","nodeValue","endElement","checkClobberedElement","tagName","nodeName","toLowerCase","srcset","elAttr","lower","trim","encodeEntities","nextNode","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","outerHTML","SURROGATE_PAIR_REGEXP","NON_ALPHANUMERIC_REGEXP","charCodeAt","_sanitizeHtml","unsafeHtmlInput","unsafeHtml","mXSSAttempts","parsedHtml","sanitizer","safeHtml","getTemplateContent","parent_1","isTemplateElement","content","SecurityContext","SAFE_STYLE_VALUE","RegExp","URL_RE","_sanitizeStyle","urlMatch","hasBalancedQuotes","outsideSingle","outsideDouble","Sanitizer","shiftInitState","priorInitState","newInitState","state","initState","initIndex","shouldCallLifecycleInitHook","asTextData","nodes","asElementData","asProviderData","asPureExpressionData","asQueryList","DebugContext","Services","setCurrentNode","createRootView","createEmbeddedView","createComponentView","createNgModuleRef","overrideProvider","overrideComponentView","clearOverrides","checkAndUpdateView","checkNoChangesView","destroyView","resolveDep","createDebugContext","handleEvent","updateDirectives","updateRenderer","dirtyParentQueries","expressionChangedAfterItHasBeenCheckedError","oldValue","currValue","isFirstCheck","viewDebugError","_addDebugContext","logError","viewDestroyedError","NOOP","_tokenKeyCache","tokenKey","UNDEFINED_RENDERER_TYPE_ID","EMPTY_RENDERER_TYPE_ID","_renderCompCount","resolveRendererType2","isFilled","None","checkBinding","bindingIdx","oldValues","bindingIndex","checkAndUpdateBinding","checkBindingNoChanges","bindingName","bindings","nodeIndex","markParentViewsForCheck","currView","viewContainerParent","markParentViewsForCheckProjectedViews","endView","dispatchEvent","event","componentView","root","declaredViewContainer","parentNodeDef","viewParentEl","renderNode","renderElement","renderText","elementEventFullName","isComponentView","isEmbeddedView","filterQueryId","queryId","splitMatchedQueriesDsl","matchedQueriesDsl","matchedQueries","matchedQueryIds","valueType","splitDepsDsl","sourceName","getParentRenderElement","renderHost","renderParent","componentRendererType","Native","DEFINITION_CACHE","WeakMap","resolveDefinition","visitRootRenderNodes","renderer","lastRenderRootNode","visitSiblingRenderNodes","startIndex","endIndex","nodeDef","visitRenderNode","childCount","visitProjectedRenderNodes","ngContentIndex","compView","hostElDef","projectedNodes","execRenderNodeAction","ngContent","rn","bindingFlags","embeddedViews","viewContainer","_embeddedViews","NS_PREFIX_RE","splitNamespace","calcBindingFlags","_toStringWithNull","elDef","selectorOrNode","ns","createComment","parentEl","selectRootElement","attrs","setAttribute","listenToElementOutputs","output","handleEventClosure","renderEventHandlerClosure","listenTarget","listenerView","disposable","listen","disposables","outputIndex","checkAndUpdateElementValue","binding","elData","renderNode$$1","setElementAttribute","securityContext","renderValue","sanitize","setElementClass","addClass","removeClass","setElementStyle","STYLE","unit","suffix","setStyle","removeStyle","setElementProperty","setProperty","UNDEFINED_VALUE","InjectorRefTokenKey$1","INJECTORRefTokenKey$1","NgModuleRefTokenKey","resolveNgModuleDep","depDef","tokenKey_1","providerDef","_def","providersByKey","providerInstance","_createProviderInstance$1","targetsModule","moduleTransitivelyPresent","modules","isRoot","injectable","_createClass","depValues","_callFactory","detachEmbeddedView","elementData","viewIndex","removeFromArray","renderDetachView","renderAttachEmbeddedView","prevView","prevRenderNode","addToArray","arr","EMPTY_CONTEXT","getComponentViewDefinitionFactory","viewDefFactory","ComponentFactory_","_inputs","_outputs","inputsArr","templateName","outputsArr","viewDef","componentNodeIndex","componentProvider","ComponentRef_","ViewRef_","_view","_viewRef","_component","_elDef","changeDetectorRef","Injector_","createViewContainerData","ViewContainerRef_","_data","ref","attachToViewContainerRef","templateRef","insert","createComponent","ngModuleRef","contextInjector","parentInjector","viewRef_","attachEmbeddedView","parentView","attachProjectedView","vcElementData","dvcElementData","projectedViews","template","_projectedViews","markNodeAsProjectedTemplate","nodeFlags","childFlags","move","moveEmbeddedView","oldViewIndex","newViewIndex","viewData","detach","createChangeDetectorRef","_viewContainerRef","_appRef","rootRenderNodes","renderNodes","markForCheck","fs","rendererFactory","begin","end","reattach","vcRef","createTemplateData","TemplateRef_","_parentView","createInjector$1","createRendererV1","RendererAdapter","namespaceAndName","createViewRoot","hostElement","createTemplateAnchor","parentElement","comment","createText","projectNodes","attachViewAfter","viewRootNodes","viewAllNodes","destroyNode","listenGlobal","propertyName","propertyValue","attributeValue","setBindingDebugInfo","className","isAdd","styleName","styleValue","invokeElementMethod","methodName","setText","setValue","animate","bootstrapComponents","NgModuleRef_","_moduleType","initNgModule","provDef","injectFlags","callNgModuleLifecycle","lifecycles","RendererV1TokenKey","Renderer2TokenKey","ElementRefTokenKey","ViewContainerRefTokenKey","TemplateRefTokenKey","ChangeDetectorRefTokenKey","InjectorRefTokenKey","INJECTORRefTokenKey","checkIndex","depDefs","directChildFlags","childMatchedQueries","createProviderInstance","_createProviderInstance","createPipeInstance","createClass","createDirectiveInstance","subscription","eventHandlerClosure","allowPrivateServices","callFactory","ViewAction","NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR","startView","tokenKey$$1","searchView","findCompView","providerDef_1","allProviders","publicProviders","providerData","updateProp","nonMinifiedName","callLifecycleHooksChildrenFirst","callProviderLifecycles","callElementProvidersLifecycles","ngAfterContentInit","ngAfterContentChecked","ngAfterViewInit","ngAfterViewChecked","queryIds","nodeMatchedQueries","tplDef","filterId","checkAndUpdateQuery","queryList","directiveInstance","newValues","elementDef","calcQueryValues","notify","boundValue","bindingType","queryDef","getQueryValue","embeddedView","dvc","projectedView","queryValueType","appendNgContent","_pureExpressionDef","propertyNames","prefix","_addInterpolationPart","isNgContainer","validateNode","nodeCount","parentEnd","anchorDef$$1","createView","initView","createViewNodes","compRenderer","rendererType","createRenderer","outputCount","bindingCount","nodeData","compViewDef","execComponentViewsAction","CreateViewNodes","execQueriesAction","markProjectedViewsForCheck","execEmbeddedViewsAction","CheckNoChanges","CheckAndUpdate","callInit","checkAndUpdateNode","argStyle","v0","v1","v2","v3","v4","v5","v6","v7","v8","v9","checkAndUpdateNodeInline","checkAndUpdateElementInline","bindLen","changed","checkAndUpdateTextInline","checkAndUpdateDirectiveInline","directive","ngOnChanges","ngOnInit","ngDoCheck","checkAndUpdatePureExpressionInline","transform","checkAndUpdateNodeDynamic","checkAndUpdateElementDynamic","checkAndUpdateTextDynamic","checkAndUpdateDirectiveDynamic","checkAndUpdatePureExpressionDynamic","i_1","checkNoChangesNode","checkNoChangesNodeInline","checkNoChangesNodeDynamic","checkNoChangesQuery","Destroy","detachProjectedView","destroyViewNodes","callViewAction","viewState","execProjectedViewsAction","CheckNoChangesProjectedViews","CheckAndUpdateProjectedViews","queryFlags","staticDynamicQueryFlag","checkType","initServicesIfNeeded","services","createDebugServices","debugSetCurrentNode","debugCreateRootView","debugCreateEmbeddedView","debugCreateComponentView","debugCreateNgModuleRef","debugOverrideProvider","debugOverrideComponentView","debugClearOverrides","debugCheckAndUpdateView","debugCheckNoChangesView","debugDestroyView","DebugContext_","debugHandleEvent","debugUpdateDirectives","debugUpdateRenderer","createProdServices","createProdRootView","prodCheckAndUpdateNode","prodCheckNoChangesNode","elInjector","createRootData","DebugRendererFactory2","defWithOverride","applyProviderOverridesToView","callWithDebugContext","DebugAction","anchorDef","viewDef$$1","viewDefOverrides","applyProviderOverridesToNgModule","calcHasOverrides","hasOverrides","hasDeprecatedOverrides","providerOverrides","override","deprecatedBehavior","providerOverridesWithScope","applyProviderOverrides","moduleSet_1","_currentAction","_currentView","_currentNodeIndex","comp","compFactory","elementIndicesWithOverwrittenProviders","findElementIndicesWithOverwrittenProviders","elIndicesWithOverwrittenProviders","lastElementDef","applyProviderOverridesToElement","elIndex","nextDirectiveWithBinding","debugCheckDirectivesFn","debugCheckAndUpdateNode","debugCheckNoChangesNode","nextRenderNodeWithBinding","debugCheckRenderNodeFn","givenValues","bindingValues","camelCaseToDashCase","CAMEL_CASE_REGEXP","normalizeDebugBindingValue","attr","elView","elOrCompView","childDef","collectReferences","findHostElement","logViewDef","logNodeIndex","renderNodeIndex","getRenderNodeIndex","currRenderNodeIndex","refName","oldAction","oldView","oldNodeIndex","isViewDebugError","viewWrappedDebugError","getCurrentDebugContext","renderData","DebugRenderer2","whenRenderingDone","removeDebugNodeFromIndex","namespace","debugCtx","debugEl","debugChildEl","debugRefEl","oldChild","style","NgModuleFactory_","_ngModuleDefFactory","queueContentHooks","tView","afterContentInit","contentHooks","afterContentChecked","contentCheckHooks","queueViewHooks","afterViewInit","viewHooks","afterViewChecked","viewCheckHooks","queueDestroyHooks","destroyHooks","executeInitHooks","currentView","creationMode","lifecycleStage","executeHooks","directives","initHooks","checkHooks","allHooks","hooksToCall","callHooks","RendererStyleFlags3","NG_PROJECT_AS_ATTR_NAME","isProceduralRenderer","domRendererFactory3","document","isDifferent","stringify$1","findNextRNodeSibling","stopNode","currentNode","pNextOrParent","findFirstRNode","currentSibling","parentType","getNextLNodeWithProjection","getNextOrParentSiblingNode","initialNode","rootNode","native","childContainerData","dynamicLContainerNode","views","head","createTextNode","addRemoveViewFromContainer","container","insertMode","beforeNode","insertView","newView","setViewNext","containerNextNativeNode","removeView","removeIndex","viewNode","destroyViewTree","rootView","viewOrContainer","cleanUpView","getParentState","queries","removeListeners","cleanup","removeEventListener","executeOnDestroys","executePipeOnDestroys","pipeDestroyHooks","canInsertNativeNode","appendProjectedNode","currentParent","lContainer","isNodeMatchingSelector","tNode","nodeClassAttrVal","cssClassToMatch","nodeClassesLen","matchIndex","matchEndIdx","mode","nodeAttrs","skipToNextSelector","isPositive","attrIndexInNode","findAttrIndexInNode","selectorAttrValue","nodeAttrValue","isNodeMatchingSelectorList","matchingSelectorIndex","selectors","textSelectors","ngProjectAsAttrVal","getProjectAsAttrValue","ngProjectAsAttrIdx","throwMultipleComponentError","throwErrorIfNoChangesMode","checkNoChangesMode","previousOrParentNode","isParent","tData","NG_HOST_SYMBOL","_CLEAN_PROMISE","_ROOT_DIRECTIVE_INDICES","CIRCULAR$2","getPreviousOrParentNode","currentQueries","getCreationMode","firstTemplatePass","enterView","host","bindingStartIndex","leaveView","refreshDirectives","executeInitAndContentHooks","setHostBindings","hostBindings","refreshChildComponents","componentRefresh","defs","dirIndex","createLView","viewId","tail","dynamicViewCount","createLNodeObject","nodeInjector","createLNode","isState","renderEmbeddedTemplate","pipes","_isParent","_previousOrParentNode","rf","getOrCreateTView","refreshDynamicChildren","getRenderFlags","createDirectivesAndLocals","localRefs","containerData","createTNode","cacheMatchingDirectivesForNode","exportsMap","","currentMatches","findDirectiveMatches","directiveRegistry","diPublic","valueIndex","resolveDirective","saveNameToExportMap","cacheMatchingLocalNames","localNames","instantiateDirectivesDirectly","count","start","tDirectives","directiveCreate","saveResolvedLocalsInData","throwCyclicDependencyError","initChangeDetectorIfExisting","_setComponentContext","exportAs","ngPrivateData","createTView","pipeRegistry","setUpAttributes","isProc","attrVal","locateHostElement","elementOrSelector","defaultRenderer","initialInputs","generatePropertyAliases","tNodeFlags","direction","propStore","isInput","directiveDef","propertyAliasMap","publicName","internalName","baseDirectiveCreate","addComponentLogic","directiveDefs","pipeDefs","addToViewTree","onPush","queueComponentIndexForCheck","queueInitHooks","onInit","doCheck","queueHostBindingForCheck","setInputsFromAttrs","directiveIndex","initialInputData","generateInitialInputs","minifiedInputName","createLContainer","parentLNode","nextIndex","container_1","elementIndex","viewAttached","detectChangesInternal","getDirectiveInstance","appendToProjectionNode","projectionNode","appendedFirst","appendedLast","projectionNodeData","findComponentHost","lView","viewRootLNode","markViewDirty","scheduleTick","rootContext","res_1","clean","scheduler","getRootView","rootComponent","renderComponentOrTemplate","componentOrContext","_getComponentHostLElementNode","hostNode","NO_CHANGE","initBindings","store","consumeBinding","bindingUpdated","checkAndUpdateBinding$1","bindingUpdated2","exp1","exp2","different","bindingUpdated4","exp3","exp4","getTView","instanceOrArray","CLEAN_PROMISE","ROOT_DIRECTIVE_INDICES","ViewRef$1","EmbeddedViewRef$1","_lViewNode","createViewRef","addDestroyable","destroyFn","NG_ELEMENT_ID","BLOOM_SIZE","nextNgElementId","getOrCreateNodeInjector","getOrCreateNodeInjectorForNode","bf0","bf1","bf2","bf3","bf4","bf5","bf6","bf7","cbf0","cbf1","cbf2","cbf3","cbf4","cbf5","cbf6","cbf7","viewContainerRef","elementRef","diPublicInInjector","di","bloomAdd","bloomBit","mask","getOrCreateChangeDetectorRef","isComponent","getOrCreateHostChangeDetector","getClosestComponentAncestor","hostInjector","getOrCreateInjectable","bloomHash","bloomHashBit","formerInjector","bloomFindPossibleInjector","flags_1","searchMatchesQueuedForCreation","startInjector","ReadFromInjectorFn","read","ElementRef$1","getOrCreateContainerRef","vcRefHost","lContainerNode","ViewContainerRef$1","_lContainerNode","_viewRefs","notImplemented","lViewNode","adjustedIdx","_adjustIndex","newIndex","shift","getOrCreateTemplateRef","TemplateRef$1","getOrCreateElementRef","getRenderer","_renderer","_directives","_pipes","_template","defineComponent","componentDefinition","pipeTypes","directiveTypes","invertObject","OnPush","extractDirectiveDef","extractPipeDef","feature","features","ngComponentDef","ngDirectiveDef","ngPipeDef","PRIVATE_PREFIX","EMPTY$1","newObj","minifiedKey","defineDirective","pureFunction1","pureFn","exp","thisArg","pureFunction2","pureFunction3","pureFunction4","pureFunctionV","exps","isPure","LQueries_","deep","shallow","track","descend","createQuery$1","containerValues","clonedQuery","viewValues","addNode","getIdxOfMatchingSelector","getIdxOfMatchingDirective","readFromNodeInjector","directiveIdx","matchingIdx","addMatch","matchingValue","previous","createPredicate","_valuesTree","QueryList$1","QueryList_","_values","flatten$1","BRAND","bypassSanitizationTrustString","trustedString","trusted","ɵangular_packages_core_core_j","ɵangular_packages_core_core_k","ɵangular_packages_core_core_l","ɵangular_packages_core_core_f","ɵangular_packages_core_core_g","ɵangular_packages_core_core_h","ɵangular_packages_core_core_i","ɵangular_packages_core_core_c","ɵangular_packages_core_core_d","ɵangular_packages_core_core_e","ɵangular_packages_core_core_m","ɵangular_packages_core_core_o","ɵangular_packages_core_core_n","ɵangular_packages_core_core_r","ɵangular_packages_core_core_p","ɵangular_packages_core_core_q","ɵangular_packages_core_core_v","ɵangular_packages_core_core_x","ɵangular_packages_core_core_w","ɵangular_packages_core_core_u","ɵangular_packages_core_core_y","ɵangular_packages_core_core_bb","ɵangular_packages_core_core_bd","ɵangular_packages_core_core_be","ɵangular_packages_core_core_bc","ɵangular_packages_core_core_ba","ɵangular_packages_core_core_z","ɵangular_packages_core_core_a","ɵangular_packages_core_core_b","ɵangular_packages_core_core_s","ɵangular_packages_core_core_t","destroyPlatform","enableProdMode","asNativeElements","debugEls","setTestabilityGetter","CUSTOM_ELEMENTS_SCHEMA","NO_ERRORS_SCHEMA","createInjector","getModuleFactory","ɵALLOW_MULTIPLE_PLATFORMS","ɵAPP_ID_RANDOM_PROVIDER","ɵdefaultIterableDiffers","ɵdevModeEqual","ɵisListLikeIterable","ɵisDefaultChangeDetectionStrategy","isDefaultChangeDetectionStrategy","changeDetectionStrategy","ɵConsole","ɵinject","ɵsetCurrentInjector","ɵAPP_ROOT","ɵComponentFactory","ɵCodegenComponentFactoryResolver","ɵReflectionCapabilities","ɵRenderDebugInfo","ɵ_sanitizeHtml","ɵ_sanitizeStyle","ɵ_sanitizeUrl","ɵglobal","ɵlooseIdentical","ɵstringify","ɵmakeDecorator","ɵisObservable","isObservable","ɵisPromise","ɵclearOverrides","ɵoverrideComponentView","ɵoverrideProvider","ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR","ɵdefineComponent","ɵdefineDirective","ɵdefinePipe","definePipe","pipeDef","ɵdetectChanges","ɵrenderComponent","renderComponent","componentDef","componentTag","requestAnimationFrame","elementNode","tag","rNode","resetApplicationState","hostFeatures","ɵdirectiveInject","directiveInject","ɵinjectTemplateRef","injectTemplateRef","ɵinjectViewContainerRef","injectViewContainerRef","ɵinjectChangeDetectorRef","injectChangeDetectorRef","ɵinjectAttribute","injectAttribute","ɵPublicFeature","PublicFeature","definition","ɵNgOnChangesFeature","NgOnChangesFeature","inputPropertyNames","proto","writable","_loop_1","pubKey","minKey","privateMinKey","existingDesc","getOwnPropertyDescriptor","simpleChanges","onChangesWrapper","delegateHook","ɵmarkDirty","markDirty","ɵNC","ɵC","ɵE","elementStart","ɵL","listenerFn","useCapture","cleanupFns","wrappedListener","wrapListenerWithDirtyLogic","cleanupFn","wrapListenerWithDirtyAndDefault","wrapListenerIn_markViewDirty","preventDefault","addEventListener","outputData","createOutput","ɵT","textNode","ɵV","embeddedViewStart","viewBlockId","scanForView","containerNode","startIdx","viewAtPositionId","getOrCreateEmbeddedTView","tContainer","ɵQ","memoryIndex","getCurrentQueries","QueryType","ɵd","loadDirective","ɵP","projection","localIndex","selectorIndex","nodesForSelector","nodeToProject","previouslyProjected","lastNodeToProject","ɵb","ɵi1","interpolation1","ɵi2","interpolation2","i0","ɵi3","interpolation3","i1","ɵi4","interpolation4","i2","ɵi5","interpolation5","i3","ɵi6","interpolation6","i4","ɵi7","interpolation7","i5","ɵi8","interpolation8","i6","ɵiV","interpolationV","ɵpb1","pipeBind1","pipeInstance","ɵpb2","pipeBind2","ɵpb3","pipeBind3","ɵpb4","pipeBind4","ɵpbV","pipeBindV","ɵf0","pureFunction0","ɵf1","ɵf2","ɵf3","ɵf4","ɵf5","pureFunction5","exp5","ɵf6","pureFunction6","exp6","ɵf7","pureFunction7","exp7","ɵf8","pureFunction8","exp8","ɵfV","ɵcR","containerRefreshStart","ɵcr","containerRefreshEnd","ɵqR","queryRefresh","ɵe","elementEnd","queueLifecycleHooks","ɵp","elementProperty","dataValue","inputData","setInputsForProperty","markDirtyIfOnPush","ɵpD","projectionDef","noOfNodeBuckets","distributedNodes","componentChild","ɵa","elementAttribute","strValue","ɵs","elementStyle","lElement","removeProperty","ɵsn","elementStyleNamed","suffixOrSanitizer","DashCase","ɵk","elementClass","ɵkn","elementClassNamed","classList","ɵt","textBinding","existingNode","textContent","insertChild","nativeSibling","ɵv","embeddedViewEnd","setRenderParentInProjectedNodes","ɵst","ɵld","ɵPp","pipeName","getPipeDef","ɵwhenRendered","whenRendered","getRootContext","ɵbypassSanitizationTrustHtml","bypassSanitizationTrustHtml","trustedHtml","ɵbypassSanitizationTrustStyle","bypassSanitizationTrustStyle","trustedStyle","ɵbypassSanitizationTrustScript","bypassSanitizationTrustScript","trustedScript","ɵbypassSanitizationTrustUrl","bypassSanitizationTrustUrl","trustedUrl","ɵbypassSanitizationTrustResourceUrl","bypassSanitizationTrustResourceUrl","trustedResourceUrl","ɵsanitizeHtml","sanitizeHtml","ɵsanitizeStyle","sanitizeStyle","unsafeStyle","ɵsanitizeUrl","sanitizeUrl","unsafeUrl","ɵsanitizeResourceUrl","sanitizeResourceUrl","unsafeResourceUrl","ɵregisterModuleFactory","registerModuleFactory","ɵEMPTY_ARRAY","ɵEMPTY_MAP","ɵand","templateFactory","ɵccf","createComponentFactory","ɵcmf","createNgModuleFactory","ngModuleType","defFactory","ɵcrt","createRendererType2","ɵdid","outputDefs","ɵeld","fixedAttrs","bindingDefs","suffixOrSecurityContext","_d","ns_1","name_1","_e","ɵelementEventFullName","ɵgetComponentViewDefinitionFactory","ɵinlineInterpolate","inlineInterpolate","valueCount","c0","a1","c1","a2","c2","a3","c3","a4","c4","a5","c5","a6","c6","a7","c7","a8","c8","a9","c9","ɵinterpolate","interpolate","constAndInterp","ɵmod","moduleDef","ɵmpd","moduleProvideDef","ɵncd","ngContentDef","ɵnov","ɵpid","ɵprd","ɵpad","pureArrayDef","argCount","ɵpod","pureObjectDef","propToIndex","nbKeys","ɵppd","purePipeDef","ɵqud","ɵted","textDef","staticText","ɵunv","unwrapValue","nodeIdx","globalBindingIdx","ɵvid","viewBindingCount","viewDisposableCount","viewNodeFlags","viewRootNodeFlags","viewMatchedQueries","currentRenderParent","currentElementHasPublicProviders","currentElementHasPrivateProviders","newParent","rootNodeFlags"],"mappings":"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","sourcesContent":["/**\n * @license Angular v6.0.7\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n */\n\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('rxjs/operators')) :\n\ttypeof define === 'function' && define.amd ? define('@angular/core', ['exports', 'rxjs', 'rxjs/operators'], factory) :\n\t(factory((global.ng = global.ng || {}, global.ng.core = {}),global.rxjs,global.rxjs.operators));\n}(this, (function (exports,rxjs,operators) { 'use strict';\n\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\nfunction __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\nvar __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\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\nfunction __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\nfunction __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\nfunction __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}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Construct an `InjectableDef` which defines how a token will be constructed by the DI system, and\n * in which injectors (if any) it will be available.\n *\n * This should be assigned to a static `ngInjectableDef` field on a type, which will then be an\n * `InjectableType`.\n *\n * Options:\n * * `providedIn` determines which injectors will include the injectable, by either associating it\n *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be\n *   provided in the `'root'` injector, which will be the application-level injector in most apps.\n * * `factory` gives the zero argument function which will create an instance of the injectable.\n *   The factory can call `inject` to access the `Injector` and request injection of dependencies.\n *\n * @experimental\n */\nfunction defineInjectable(opts) {\n    return {\n        providedIn: opts.providedIn || null, factory: opts.factory, value: undefined,\n    };\n}\n/**\n * Construct an `InjectorDef` which configures an injector.\n *\n * This should be assigned to a static `ngInjectorDef` field on a type, which will then be an\n * `InjectorType`.\n *\n * Options:\n *\n * * `factory`: an `InjectorType` is an instantiable type, so a zero argument `factory` function to\n *   create the type must be provided. If that factory function needs to inject arguments, it can\n *   use the `inject` function.\n * * `providers`: an optional array of providers to add to the injector. Each provider must\n *   either have a factory or point to a type which has an `ngInjectableDef` static property (the\n *   type must be an `InjectableType`).\n * * `imports`: an optional array of imports of other `InjectorType`s or `InjectorTypeWithModule`s\n *   whose providers will also be added to the injector. Locally provided types will override\n *   providers from imports.\n *\n * @experimental\n */\nfunction defineInjector(options) {\n    return {\n        factory: options.factory, providers: options.providers || [], imports: options.imports || [],\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 * 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 * When creating an `InjectionToken`, you can optionally specify a factory function which returns\n * (possibly by creating) a default value of the parameterized type `T`. This sets up the\n * `InjectionToken` using this factory as a provider as if it was defined explicitly in the\n * application's root injector. If the factory function, which takes zero arguments, needs to inject\n * dependencies, it can do so using the `inject` function. See below for an example.\n *\n * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which\n * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As\n * mentioned above, `'root'` is the default value for `providedIn`.\n *\n * @usageNotes\n * ### Basic Example\n *\n * {@example core/di/ts/injector_spec.ts region='InjectionToken'}\n *\n * ### Tree-shakeable Example\n *\n * {@example core/di/ts/injector_spec.ts region='ShakeableInjectionToken'}\n *\n */\nvar InjectionToken = /** @class */ (function () {\n    function InjectionToken(_desc, options) {\n        this._desc = _desc;\n        /** @internal */\n        this.ngMetadataName = 'InjectionToken';\n        if (options !== undefined) {\n            this.ngInjectableDef = defineInjectable({\n                providedIn: options.providedIn || 'root',\n                factory: options.factory,\n            });\n        }\n        else {\n            this.ngInjectableDef = undefined;\n        }\n    }\n    InjectionToken.prototype.toString = function () { return \"InjectionToken \" + this._desc; };\n    return InjectionToken;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ANNOTATIONS = '__annotations__';\nvar PARAMETERS = '__parameters__';\nvar PROP_METADATA = '__prop__metadata__';\n/**\n * @suppress {globalThis}\n */\nfunction makeDecorator(name, props, parentClass, chainFn, typeFn) {\n    var metaCtor = makeMetadataCtor(props);\n    function DecoratorFactory() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (this instanceof DecoratorFactory) {\n            metaCtor.call.apply(metaCtor, __spread([this], args));\n            return this;\n        }\n        var annotationInstance = new ((_a = DecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n        var TypeDecorator = function TypeDecorator(cls) {\n            typeFn && typeFn.apply(void 0, __spread([cls], args));\n            // Use of Object.defineProperty is important since it creates non-enumerable property which\n            // prevents the property is copied during subclassing.\n            var annotations = cls.hasOwnProperty(ANNOTATIONS) ?\n                cls[ANNOTATIONS] :\n                Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];\n            annotations.push(annotationInstance);\n            return cls;\n        };\n        if (chainFn)\n            chainFn(TypeDecorator);\n        return TypeDecorator;\n        var _a;\n    }\n    if (parentClass) {\n        DecoratorFactory.prototype = Object.create(parentClass.prototype);\n    }\n    DecoratorFactory.prototype.ngMetadataName = name;\n    DecoratorFactory.annotationCls = DecoratorFactory;\n    return DecoratorFactory;\n}\nfunction makeMetadataCtor(props) {\n    return function ctor() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (props) {\n            var values = props.apply(void 0, __spread(args));\n            for (var propName in values) {\n                this[propName] = values[propName];\n            }\n        }\n    };\n}\nfunction makeParamDecorator(name, props, parentClass) {\n    var metaCtor = makeMetadataCtor(props);\n    function ParamDecoratorFactory() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (this instanceof ParamDecoratorFactory) {\n            metaCtor.apply(this, args);\n            return this;\n        }\n        var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n        ParamDecorator.annotation = annotationInstance;\n        return ParamDecorator;\n        function ParamDecorator(cls, unusedKey, index) {\n            // Use of Object.defineProperty is important since it creates non-enumerable property which\n            // prevents the property is copied during subclassing.\n            var parameters = cls.hasOwnProperty(PARAMETERS) ?\n                cls[PARAMETERS] :\n                Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];\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            (parameters[index] = parameters[index] || []).push(annotationInstance);\n            return cls;\n        }\n        var _a;\n    }\n    if (parentClass) {\n        ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);\n    }\n    ParamDecoratorFactory.prototype.ngMetadataName = name;\n    ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;\n    return ParamDecoratorFactory;\n}\nfunction makePropDecorator(name, props, parentClass) {\n    var metaCtor = makeMetadataCtor(props);\n    function PropDecoratorFactory() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (this instanceof PropDecoratorFactory) {\n            metaCtor.apply(this, args);\n            return this;\n        }\n        var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n        return function PropDecorator(target, name) {\n            var constructor = target.constructor;\n            // Use of Object.defineProperty is important since it creates non-enumerable property which\n            // prevents the property is copied during subclassing.\n            var meta = constructor.hasOwnProperty(PROP_METADATA) ?\n                constructor[PROP_METADATA] :\n                Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];\n            meta[name] = meta.hasOwnProperty(name) && meta[name] || [];\n            meta[name].unshift(decoratorInstance);\n        };\n        var _a;\n    }\n    if (parentClass) {\n        PropDecoratorFactory.prototype = Object.create(parentClass.prototype);\n    }\n    PropDecoratorFactory.prototype.ngMetadataName = name;\n    PropDecoratorFactory.annotationCls = PropDecoratorFactory;\n    return PropDecoratorFactory;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This token can be used to create a virtual provider that will populate the\n * `entryComponents` fields of components and ng modules based on its `useValue`.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) will be added to the `entryComponents` property.\n *\n * @usageNotes\n * ### Example\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on the router configuration which refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n *   return [\n *     {provide: ROUTES, useValue: routes},\n *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n *   ];\n * }\n *\n * // user code\n * let routes = [\n *   {path: '/root', component: RootComp},\n *   {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n *   providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @experimental\n */\nvar ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');\n/**\n * Attribute decorator and metadata.\n *\n * @Annotation\n */\nvar Attribute = makeParamDecorator('Attribute', function (attributeName) { return ({ attributeName: attributeName }); });\n/**\n * Base class for query metadata.\n *\n * @see `ContentChildren`.\n * @see `ContentChild`.\n * @see `ViewChildren`.\n * @see `ViewChild`.\n */\nvar Query = /** @class */ (function () {\n    function Query() {\n    }\n    return Query;\n}());\n/**\n * ContentChildren decorator and metadata.\n *\n *\n *  @Annotation\n */\nvar ContentChildren = makePropDecorator('ContentChildren', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: false, isViewQuery: false, descendants: false }, data));\n}, Query);\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n */\nvar ContentChild = makePropDecorator('ContentChild', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: true, isViewQuery: false, descendants: true }, data));\n}, Query);\n/**\n * ViewChildren decorator and metadata.\n *\n * @Annotation\n */\nvar ViewChildren = makePropDecorator('ViewChildren', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: false, isViewQuery: true, descendants: true }, data));\n}, Query);\n/**\n * ViewChild decorator and metadata.\n *\n * @Annotation\n */\nvar ViewChild = makePropDecorator('ViewChild', function (selector, data) {\n    return (__assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data));\n}, Query);\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 * Describes within the change detector which strategy will be used the next time change\n * detection is triggered.\n *\n */\n\n(function (ChangeDetectionStrategy) {\n    /**\n     * `OnPush` means that the change detector's mode will be initially set to `CheckOnce`.\n     */\n    ChangeDetectionStrategy[ChangeDetectionStrategy[\"OnPush\"] = 0] = \"OnPush\";\n    /**\n     * `Default` means that the change detector's mode will be initially set to `CheckAlways`.\n     */\n    ChangeDetectionStrategy[ChangeDetectionStrategy[\"Default\"] = 1] = \"Default\";\n})(exports.ChangeDetectionStrategy || (exports.ChangeDetectionStrategy = {}));\n/**\n * Describes the status of the detector.\n */\n\n(function (ChangeDetectorStatus) {\n    /**\n     * `CheckOnce` means that after calling detectChanges the mode of the change detector\n     * will become `Checked`.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"CheckOnce\"] = 0] = \"CheckOnce\";\n    /**\n     * `Checked` means that the change detector should be skipped until its mode changes to\n     * `CheckOnce`.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Checked\"] = 1] = \"Checked\";\n    /**\n     * `CheckAlways` means that after calling detectChanges the mode of the change detector\n     * will remain `CheckAlways`.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"CheckAlways\"] = 2] = \"CheckAlways\";\n    /**\n     * `Detached` means that the change detector sub tree is not a part of the main tree and\n     * should be skipped.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Detached\"] = 3] = \"Detached\";\n    /**\n     * `Errored` means that the change detector encountered an error checking a binding\n     * or calling a directive lifecycle method and is now in an inconsistent state. Change\n     * detectors in this state will no longer detect changes.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Errored\"] = 4] = \"Errored\";\n    /**\n     * `Destroyed` means that the change detector is destroyed.\n     */\n    ChangeDetectorStatus[ChangeDetectorStatus[\"Destroyed\"] = 5] = \"Destroyed\";\n})(exports.ɵChangeDetectorStatus || (exports.ɵChangeDetectorStatus = {}));\nfunction isDefaultChangeDetectionStrategy(changeDetectionStrategy) {\n    return changeDetectionStrategy == null ||\n        changeDetectionStrategy === exports.ChangeDetectionStrategy.Default;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Type of the Component metadata.\n */\nvar Directive = makeDecorator('Directive', function (dir) {\n    if (dir === void 0) { dir = {}; }\n    return dir;\n});\n/**\n * Component decorator and metadata.\n *\n * @usageNotes\n *\n * ### Using animations\n *\n * The following snippet shows an animation trigger in a component's\n * metadata. The trigger is attached to an element in the component's\n * template, using \"@_trigger_name_\", and a state expression that is evaluated\n * at run time to determine whether the animation should start.\n *\n * ```typescript\n * @Component({\n *   selector: 'animation-cmp',\n *   templateUrl: 'animation-cmp.html',\n *   animations: [\n *     trigger('myTriggerName', [\n *       state('on', style({ opacity: 1 }),\n *       state('off', style({ opacity: 0 }),\n *       transition('on => off', [\n *         animate(\"1s\")\n *       ])\n *     ])\n *   ]\n * })\n * ```\n *\n * ```html\n * <!-- animation-cmp.html -->\n * <div @myTriggerName=\"expression\">...</div>\n * ```\n *\n * ### Preserving whitespace\n *\n * Removing whitespace can greatly reduce AOT-generated code size, and speed up view creation.\n * As of Angular 6, default for `preserveWhitespaces` is false (whitespace is removed).\n * To change the default setting for all components in your application, set\n * the `preserveWhitespaces` option of the AOT compiler.\n *\n * Current implementation removes whitespace characters as follows:\n * - Trims all whitespaces at the beginning and the end of a template.\n * - Removes whitespace-only text nodes. For example,\n * `<button>Action 1</button>  <button>Action 2</button>` becomes\n * `<button>Action 1</button><button>Action 2</button>`.\n * - Replaces a series of whitespace characters in text nodes with a single space.\n * For example, `<span>\\n some text\\n</span>` becomes `<span> some text </span>`.\n * - Does NOT alter text nodes inside HTML tags such as `<pre>` or `<textarea>`,\n * where whitespace characters are significant.\n *\n * Note that these transformations can influence DOM nodes layout, although impact\n * should be minimal.\n *\n * You can override the default behavior to preserve whitespace characters\n * in certain fragments of a template. For example, you can exclude an entire\n * DOM sub-tree by using the `ngPreserveWhitespaces` attribute:\n *\n * ```html\n * <div ngPreserveWhitespaces>\n *     whitespaces are preserved here\n *     <span>    and here </span>\n * </div>\n * ```\n *\n * You can force a single space to be preserved in a text node by using `&ngsp;`,\n * which is replaced with a space character by Angular's template\n * compiler:\n *\n * ```html\n * <a>Spaces</a>&ngsp;<a>between</a>&ngsp;<a>links.</a>\n * <!-->compiled to be equivalent to:</>\n *  <a>Spaces</a> <a>between</a> <a>links.</a>\n * ```\n *\n * Note that sequences of `&ngsp;` are still collapsed to just one space character when\n * the `preserveWhitespaces` option is set to `false`.\n *\n * ```html\n * <a>before</a>&ngsp;&ngsp;&ngsp;<a>after</a>\n * <!-->compiled to be equivalent to:</>\n *  <a>Spaces</a> <a>between</a> <a>links.</a>\n * ```\n *\n * To preserve sequences of whitespace characters, use the\n * `ngPreserveWhitespaces` attribute.\n *\n * @Annotation\n */\nvar Component = makeDecorator('Component', function (c) {\n    if (c === void 0) { c = {}; }\n    return (__assign({ changeDetection: exports.ChangeDetectionStrategy.Default }, c));\n}, Directive);\n/**\n *\n *\n * @Annotation\n */\nvar Pipe = makeDecorator('Pipe', function (p) { return (__assign({ pure: true }, p)); });\n/**\n *\n * @Annotation\n */\nvar Input = makePropDecorator('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });\n/**\n *\n * @Annotation\n */\nvar Output = makePropDecorator('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });\n/**\n *\n * @Annotation\n */\nvar HostBinding = makePropDecorator('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); });\n/**\n * Binds a CSS event to a host listener and supplies configuration metadata.\n * Angular invokes the supplied handler method when the host element emits the specified event,\n * and updates the bound element with the result.\n * If the handler method returns false, applies `preventDefault` on the bound element.\n *\n * @usageNotes\n *\n * The following example declares a directive\n * that attaches a click listener to a button and counts clicks.\n *\n * ```\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 *\n * @Annotation\n */\nvar HostListener = makePropDecorator('HostListener', function (eventName, args) { return ({ eventName: eventName, args: args }); });\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description\n *\n * Represents a type that a Component or other object is instances of.\n *\n * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by\n * the `MyCustomComponent` constructor function.\n *\n *\n */\nvar Type = Function;\nfunction isType(v) {\n    return typeof v === 'function';\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\nvar _global = __window || __global || __self;\nvar promise = Promise.resolve(0);\nvar _symbolIterator = null;\nfunction getSymbolIterator() {\n    if (!_symbolIterator) {\n        var Symbol_1 = _global['Symbol'];\n        if (Symbol_1 && Symbol_1.iterator) {\n            _symbolIterator = Symbol_1.iterator;\n        }\n        else {\n            // es6-shim specific logic\n            var keys = Object.getOwnPropertyNames(Map.prototype);\n            for (var i = 0; i < keys.length; ++i) {\n                var key = keys[i];\n                if (key !== 'entries' && key !== 'size' &&\n                    Map.prototype[key] === Map.prototype['entries']) {\n                    _symbolIterator = key;\n                }\n            }\n        }\n    }\n    return _symbolIterator;\n}\nfunction scheduleMicroTask(fn) {\n    if (typeof Zone === 'undefined') {\n        // use promise to schedule microTask instead of use Zone\n        promise.then(function () { fn && fn.apply(null, null); });\n    }\n    else {\n        Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n    }\n}\n// JS has NaN !== NaN\nfunction looseIdentical(a, b) {\n    return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);\n}\nfunction stringify(token) {\n    if (typeof token === 'string') {\n        return token;\n    }\n    if (token instanceof Array) {\n        return '[' + token.map(stringify).join(', ') + ']';\n    }\n    if (token == null) {\n        return '' + token;\n    }\n    if (token.overriddenName) {\n        return \"\" + token.overriddenName;\n    }\n    if (token.name) {\n        return \"\" + token.name;\n    }\n    var res = token.toString();\n    if (res == null) {\n        return '' + res;\n    }\n    var newLineIndex = res.indexOf('\\n');\n    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\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 * Attention: These regex has to hold even if the code is minified!\n */\nvar DELEGATE_CTOR = /^function\\s+\\S+\\(\\)\\s*{[\\s\\S]+\\.apply\\(this,\\s*arguments\\)/;\nvar INHERITED_CLASS = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[A-Za-z\\d$_]+\\s*{/;\nvar INHERITED_CLASS_WITH_CTOR = /^class\\s+[A-Za-z\\d$_]*\\s*extends\\s+[A-Za-z\\d$_]+\\s*{[\\s\\S]*constructor\\s*\\(/;\nvar ReflectionCapabilities = /** @class */ (function () {\n    function ReflectionCapabilities(reflect) {\n        this._reflect = reflect || _global['Reflect'];\n    }\n    ReflectionCapabilities.prototype.isReflectionEnabled = function () { return true; };\n    ReflectionCapabilities.prototype.factory = function (t) { return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new (t.bind.apply(t, __spread([void 0], args)))();\n    }; };\n    /** @internal */\n    ReflectionCapabilities.prototype._zipTypesAndAnnotations = function (paramTypes, paramAnnotations) {\n        var result;\n        if (typeof paramTypes === 'undefined') {\n            result = new Array(paramAnnotations.length);\n        }\n        else {\n            result = new Array(paramTypes.length);\n        }\n        for (var 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            }\n            else if (paramTypes[i] != Object) {\n                result[i] = [paramTypes[i]];\n            }\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    ReflectionCapabilities.prototype._ownParameters = function (type, parentCtor) {\n        var typeStr = type.toString();\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(typeStr) ||\n            (INHERITED_CLASS.exec(typeStr) && !INHERITED_CLASS_WITH_CTOR.exec(typeStr))) {\n            return null;\n        }\n        // Prefer the direct API.\n        if (type.parameters && type.parameters !== parentCtor.parameters) {\n            return type.parameters;\n        }\n        // API of tsickle for lowering decorators to properties on the class.\n        var tsickleCtorParams = 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            var ctorParameters = typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;\n            var paramTypes_1 = ctorParameters.map(function (ctorParam) { return ctorParam && ctorParam.type; });\n            var paramAnnotations_1 = ctorParameters.map(function (ctorParam) {\n                return ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators);\n            });\n            return this._zipTypesAndAnnotations(paramTypes_1, paramAnnotations_1);\n        }\n        // API for metadata created by invoking the decorators.\n        var paramAnnotations = type.hasOwnProperty(PARAMETERS) && type[PARAMETERS];\n        var paramTypes = this._reflect && this._reflect.getOwnMetadata &&\n            this._reflect.getOwnMetadata('design:paramtypes', type);\n        if (paramTypes || paramAnnotations) {\n            return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);\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.length).fill(undefined);\n    };\n    ReflectionCapabilities.prototype.parameters = function (type) {\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        var parentCtor = getParentCtor(type);\n        var parameters = this._ownParameters(type, parentCtor);\n        if (!parameters && parentCtor !== Object) {\n            parameters = this.parameters(parentCtor);\n        }\n        return parameters || [];\n    };\n    ReflectionCapabilities.prototype._ownAnnotations = function (typeOrFunc, parentCtor) {\n        // Prefer the direct API.\n        if (typeOrFunc.annotations && typeOrFunc.annotations !== parentCtor.annotations) {\n            var annotations = typeOrFunc.annotations;\n            if (typeof annotations === 'function' && annotations.annotations) {\n                annotations = annotations.annotations;\n            }\n            return annotations;\n        }\n        // API of tsickle for lowering decorators to properties on the class.\n        if (typeOrFunc.decorators && typeOrFunc.decorators !== parentCtor.decorators) {\n            return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);\n        }\n        // API for metadata created by invoking the decorators.\n        if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {\n            return typeOrFunc[ANNOTATIONS];\n        }\n        return null;\n    };\n    ReflectionCapabilities.prototype.annotations = function (typeOrFunc) {\n        if (!isType(typeOrFunc)) {\n            return [];\n        }\n        var parentCtor = getParentCtor(typeOrFunc);\n        var ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];\n        var parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];\n        return parentAnnotations.concat(ownAnnotations);\n    };\n    ReflectionCapabilities.prototype._ownPropMetadata = function (typeOrFunc, parentCtor) {\n        // Prefer the direct API.\n        if (typeOrFunc.propMetadata &&\n            typeOrFunc.propMetadata !== parentCtor.propMetadata) {\n            var propMetadata = typeOrFunc.propMetadata;\n            if (typeof propMetadata === 'function' && propMetadata.propMetadata) {\n                propMetadata = propMetadata.propMetadata;\n            }\n            return propMetadata;\n        }\n        // API of tsickle for lowering decorators to properties on the class.\n        if (typeOrFunc.propDecorators &&\n            typeOrFunc.propDecorators !== parentCtor.propDecorators) {\n            var propDecorators_1 = typeOrFunc.propDecorators;\n            var propMetadata_1 = {};\n            Object.keys(propDecorators_1).forEach(function (prop) {\n                propMetadata_1[prop] = convertTsickleDecoratorIntoMetadata(propDecorators_1[prop]);\n            });\n            return propMetadata_1;\n        }\n        // API for metadata created by invoking the decorators.\n        if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {\n            return typeOrFunc[PROP_METADATA];\n        }\n        return null;\n    };\n    ReflectionCapabilities.prototype.propMetadata = function (typeOrFunc) {\n        if (!isType(typeOrFunc)) {\n            return {};\n        }\n        var parentCtor = getParentCtor(typeOrFunc);\n        var propMetadata = {};\n        if (parentCtor !== Object) {\n            var parentPropMetadata_1 = this.propMetadata(parentCtor);\n            Object.keys(parentPropMetadata_1).forEach(function (propName) {\n                propMetadata[propName] = parentPropMetadata_1[propName];\n            });\n        }\n        var ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);\n        if (ownPropMetadata) {\n            Object.keys(ownPropMetadata).forEach(function (propName) {\n                var decorators = [];\n                if (propMetadata.hasOwnProperty(propName)) {\n                    decorators.push.apply(decorators, __spread(propMetadata[propName]));\n                }\n                decorators.push.apply(decorators, __spread(ownPropMetadata[propName]));\n                propMetadata[propName] = decorators;\n            });\n        }\n        return propMetadata;\n    };\n    ReflectionCapabilities.prototype.hasLifecycleHook = function (type, lcProperty) {\n        return type instanceof Type && lcProperty in type.prototype;\n    };\n    ReflectionCapabilities.prototype.guards = function (type) { return {}; };\n    ReflectionCapabilities.prototype.getter = function (name) { return new Function('o', 'return o.' + name + ';'); };\n    ReflectionCapabilities.prototype.setter = function (name) {\n        return new Function('o', 'v', 'return o.' + name + ' = v;');\n    };\n    ReflectionCapabilities.prototype.method = function (name) {\n        var functionBody = \"if (!o.\" + name + \") throw new Error('\\\"\" + name + \"\\\" is undefined');\\n        return o.\" + name + \".apply(o, args);\";\n        return new Function('o', 'args', functionBody);\n    };\n    // There is not a concept of import uri in Js, but this is useful in developing Dart applications.\n    ReflectionCapabilities.prototype.importUri = function (type) {\n        // StaticSymbol\n        if (typeof type === 'object' && type['filePath']) {\n            return type['filePath'];\n        }\n        // Runtime type\n        return \"./\" + stringify(type);\n    };\n    ReflectionCapabilities.prototype.resourceUri = function (type) { return \"./\" + stringify(type); };\n    ReflectionCapabilities.prototype.resolveIdentifier = function (name, moduleUrl, members, runtime) {\n        return runtime;\n    };\n    ReflectionCapabilities.prototype.resolveEnum = function (enumIdentifier, name) { return enumIdentifier[name]; };\n    return ReflectionCapabilities;\n}());\nfunction convertTsickleDecoratorIntoMetadata(decoratorInvocations) {\n    if (!decoratorInvocations) {\n        return [];\n    }\n    return decoratorInvocations.map(function (decoratorInvocation) {\n        var decoratorType = decoratorInvocation.type;\n        var annotationCls = decoratorType.annotationCls;\n        var annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];\n        return new (annotationCls.bind.apply(annotationCls, __spread([void 0], annotationArgs)))();\n    });\n}\nfunction getParentCtor(ctor) {\n    var parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;\n    var 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/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction getClosureSafeProperty(objWithPropertyToExtract, target) {\n    for (var key in objWithPropertyToExtract) {\n        if (objWithPropertyToExtract[key] === target) {\n            return key;\n        }\n    }\n    throw Error('Could not find renamed property on target object.');\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 * Allows to refer to references which are not yet defined.\n *\n * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of\n * DI is declared, but not yet defined. It is also used when the `token` which we use when creating\n * a query is not yet defined.\n *\n * @usageNotes\n * ### Example\n * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}\n * @experimental\n */\nfunction forwardRef(forwardRefFn) {\n    forwardRefFn.__forward_ref__ = forwardRef;\n    forwardRefFn.toString = function () { return stringify(this()); };\n    return forwardRefFn;\n}\n/**\n * Lazily retrieves the reference value from a forwardRef.\n *\n * Acts as the identity function when given a non-forward-ref value.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}\n *\n * @see `forwardRef`\n * @experimental\n */\nfunction resolveForwardRef(type) {\n    if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__') &&\n        type.__forward_ref__ === forwardRef) {\n        return type();\n    }\n    else {\n        return type;\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 * Inject decorator and metadata.\n *\n * @Annotation\n */\nvar Inject = makeParamDecorator('Inject', function (token) { return ({ token: token }); });\n/**\n * Optional decorator and metadata.\n *\n * @Annotation\n */\nvar Optional = makeParamDecorator('Optional');\n/**\n * Self decorator and metadata.\n *\n * @Annotation\n */\nvar Self = makeParamDecorator('Self');\n/**\n * SkipSelf decorator and metadata.\n *\n * @Annotation\n */\nvar SkipSelf = makeParamDecorator('SkipSelf');\n/**\n * Host decorator and metadata.\n *\n * @Annotation\n */\nvar Host = makeParamDecorator('Host');\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar SOURCE = '__source';\nvar _THROW_IF_NOT_FOUND = new Object();\nvar THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n/**\n * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.\n *\n * Requesting this token instead of `Injector` allows `StaticInjector` to be tree-shaken from a\n * project.\n *\n * @experimental\n */\nvar INJECTOR = new InjectionToken('INJECTOR');\nvar NullInjector = /** @class */ (function () {\n    function NullInjector() {\n    }\n    NullInjector.prototype.get = function (token, notFoundValue) {\n        if (notFoundValue === void 0) { notFoundValue = _THROW_IF_NOT_FOUND; }\n        if (notFoundValue === _THROW_IF_NOT_FOUND) {\n            throw new Error(\"NullInjectorError: No provider for \" + stringify(token) + \"!\");\n        }\n        return notFoundValue;\n    };\n    return NullInjector;\n}());\n/**\n * Concrete injectors implement this interface.\n *\n * For more details, see the [\"Dependency Injection Guide\"](guide/dependency-injection).\n *\n * @usageNotes\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 *\n * {@example core/di/ts/injector_spec.ts region='injectInjector'}\n *\n *\n */\nvar Injector = /** @class */ (function () {\n    function Injector() {\n    }\n    /**\n     * Create a new Injector which is configure using `StaticProvider`s.\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n     */\n    Injector.create = function (options, parent) {\n        if (Array.isArray(options)) {\n            return new StaticInjector(options, parent);\n        }\n        else {\n            return new StaticInjector(options.providers, options.parent, options.name || null);\n        }\n    };\n    Injector.THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n    Injector.NULL = new NullInjector();\n    Injector.ngInjectableDef = defineInjectable({\n        providedIn: 'any',\n        factory: function () { return inject(INJECTOR); },\n    });\n    return Injector;\n}());\nvar IDENT = function (value) {\n    return value;\n};\nvar EMPTY = [];\nvar CIRCULAR = IDENT;\nvar MULTI_PROVIDER_FN = function () {\n    return Array.prototype.slice.call(arguments);\n};\nvar GET_PROPERTY_NAME$1 = {};\nvar USE_VALUE$1 = getClosureSafeProperty$1({ provide: String, useValue: GET_PROPERTY_NAME$1 });\nvar NG_TOKEN_PATH = 'ngTokenPath';\nvar NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\nvar NULL_INJECTOR = Injector.NULL;\nvar NEW_LINE = /\\n/gm;\nvar NO_NEW_LINE = 'ɵ';\nvar StaticInjector = /** @class */ (function () {\n    function StaticInjector(providers, parent, source) {\n        if (parent === void 0) { parent = NULL_INJECTOR; }\n        if (source === void 0) { source = null; }\n        this.parent = parent;\n        this.source = source;\n        var records = this._records = new Map();\n        records.set(Injector, { token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false });\n        records.set(INJECTOR, { token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false });\n        recursivelyProcessProviders(records, providers);\n    }\n    StaticInjector.prototype.get = function (token, notFoundValue, flags) {\n        if (flags === void 0) { flags = 0 /* Default */; }\n        var record = this._records.get(token);\n        try {\n            return tryResolveToken(token, record, this._records, this.parent, notFoundValue, flags);\n        }\n        catch (e) {\n            var tokenPath = e[NG_TEMP_TOKEN_PATH];\n            if (token[SOURCE]) {\n                tokenPath.unshift(token[SOURCE]);\n            }\n            e.message = formatError('\\n' + e.message, tokenPath, this.source);\n            e[NG_TOKEN_PATH] = tokenPath;\n            e[NG_TEMP_TOKEN_PATH] = null;\n            throw e;\n        }\n    };\n    StaticInjector.prototype.toString = function () {\n        var tokens = [], records = this._records;\n        records.forEach(function (v, token) { return tokens.push(stringify(token)); });\n        return \"StaticInjector[\" + tokens.join(', ') + \"]\";\n    };\n    return StaticInjector;\n}());\nfunction resolveProvider(provider) {\n    var deps = computeDeps(provider);\n    var fn = IDENT;\n    var value = EMPTY;\n    var useNew = false;\n    var provide = resolveForwardRef(provider.provide);\n    if (USE_VALUE$1 in provider) {\n        // We need to use USE_VALUE in provider since provider.useValue could be defined as undefined.\n        value = provider.useValue;\n    }\n    else if (provider.useFactory) {\n        fn = provider.useFactory;\n    }\n    else if (provider.useExisting) {\n        // Just use IDENT\n    }\n    else if (provider.useClass) {\n        useNew = true;\n        fn = resolveForwardRef(provider.useClass);\n    }\n    else if (typeof provide == 'function') {\n        useNew = true;\n        fn = provide;\n    }\n    else {\n        throw staticError('StaticProvider does not have [useValue|useFactory|useExisting|useClass] or [provide] is not newable', provider);\n    }\n    return { deps: deps, fn: fn, useNew: useNew, value: value };\n}\nfunction multiProviderMixError(token) {\n    return staticError('Cannot mix multi providers and regular providers', token);\n}\nfunction recursivelyProcessProviders(records, provider) {\n    if (provider) {\n        provider = resolveForwardRef(provider);\n        if (provider instanceof Array) {\n            // if we have an array recurse into the array\n            for (var i = 0; i < provider.length; i++) {\n                recursivelyProcessProviders(records, provider[i]);\n            }\n        }\n        else if (typeof provider === 'function') {\n            // Functions were supported in ReflectiveInjector, but are not here. For safety give useful\n            // error messages\n            throw staticError('Function/Class not supported', provider);\n        }\n        else if (provider && typeof provider === 'object' && provider.provide) {\n            // At this point we have what looks like a provider: {provide: ?, ....}\n            var token = resolveForwardRef(provider.provide);\n            var resolvedProvider = resolveProvider(provider);\n            if (provider.multi === true) {\n                // This is a multi provider.\n                var multiProvider = records.get(token);\n                if (multiProvider) {\n                    if (multiProvider.fn !== MULTI_PROVIDER_FN) {\n                        throw multiProviderMixError(token);\n                    }\n                }\n                else {\n                    // Create a placeholder factory which will look up the constituents of the multi provider.\n                    records.set(token, multiProvider = {\n                        token: provider.provide,\n                        deps: [],\n                        useNew: false,\n                        fn: MULTI_PROVIDER_FN,\n                        value: EMPTY\n                    });\n                }\n                // Treat the provider as the token.\n                token = provider;\n                multiProvider.deps.push({ token: token, options: 6 /* Default */ });\n            }\n            var record = records.get(token);\n            if (record && record.fn == MULTI_PROVIDER_FN) {\n                throw multiProviderMixError(token);\n            }\n            records.set(token, resolvedProvider);\n        }\n        else {\n            throw staticError('Unexpected provider', provider);\n        }\n    }\n}\nfunction tryResolveToken(token, record, records, parent, notFoundValue, flags) {\n    try {\n        return resolveToken(token, record, records, parent, notFoundValue, flags);\n    }\n    catch (e) {\n        // ensure that 'e' is of type Error.\n        if (!(e instanceof Error)) {\n            e = new Error(e);\n        }\n        var path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];\n        path.unshift(token);\n        if (record && record.value == CIRCULAR) {\n            // Reset the Circular flag.\n            record.value = EMPTY;\n        }\n        throw e;\n    }\n}\nfunction resolveToken(token, record, records, parent, notFoundValue, flags) {\n    var value;\n    if (record && !(flags & 4 /* SkipSelf */)) {\n        // If we don't have a record, this implies that we don't own the provider hence don't know how\n        // to resolve it.\n        value = record.value;\n        if (value == CIRCULAR) {\n            throw Error(NO_NEW_LINE + 'Circular dependency');\n        }\n        else if (value === EMPTY) {\n            record.value = CIRCULAR;\n            var obj = undefined;\n            var useNew = record.useNew;\n            var fn = record.fn;\n            var depRecords = record.deps;\n            var deps = EMPTY;\n            if (depRecords.length) {\n                deps = [];\n                for (var i = 0; i < depRecords.length; i++) {\n                    var depRecord = depRecords[i];\n                    var options = depRecord.options;\n                    var childRecord = options & 2 /* CheckSelf */ ? records.get(depRecord.token) : undefined;\n                    deps.push(tryResolveToken(\n                    // Current Token to resolve\n                    depRecord.token, \n                    // A record which describes how to resolve the token.\n                    // If undefined, this means we don't have such a record\n                    childRecord, \n                    // Other records we know about.\n                    records, \n                    // If we don't know how to resolve dependency and we should not check parent for it,\n                    // than pass in Null injector.\n                    !childRecord && !(options & 4 /* CheckParent */) ? NULL_INJECTOR : parent, options & 1 /* Optional */ ? null : Injector.THROW_IF_NOT_FOUND, 0 /* Default */));\n                }\n            }\n            record.value = value = useNew ? new ((_a = fn).bind.apply(_a, __spread([void 0], deps)))() : fn.apply(obj, deps);\n        }\n    }\n    else if (!(flags & 2 /* Self */)) {\n        value = parent.get(token, notFoundValue, 0 /* Default */);\n    }\n    return value;\n    var _a;\n}\nfunction computeDeps(provider) {\n    var deps = EMPTY;\n    var providerDeps = provider.deps;\n    if (providerDeps && providerDeps.length) {\n        deps = [];\n        for (var i = 0; i < providerDeps.length; i++) {\n            var options = 6;\n            var token = resolveForwardRef(providerDeps[i]);\n            if (token instanceof Array) {\n                for (var j = 0, annotations = token; j < annotations.length; j++) {\n                    var annotation = annotations[j];\n                    if (annotation instanceof Optional || annotation == Optional) {\n                        options = options | 1 /* Optional */;\n                    }\n                    else if (annotation instanceof SkipSelf || annotation == SkipSelf) {\n                        options = options & ~2 /* CheckSelf */;\n                    }\n                    else if (annotation instanceof Self || annotation == Self) {\n                        options = options & ~4 /* CheckParent */;\n                    }\n                    else if (annotation instanceof Inject) {\n                        token = annotation.token;\n                    }\n                    else {\n                        token = resolveForwardRef(annotation);\n                    }\n                }\n            }\n            deps.push({ token: token, options: options });\n        }\n    }\n    else if (provider.useExisting) {\n        var token = resolveForwardRef(provider.useExisting);\n        deps = [{ token: token, options: 6 /* Default */ }];\n    }\n    else if (!providerDeps && !(USE_VALUE$1 in provider)) {\n        // useValue & useExisting are the only ones which are exempt from deps all others need it.\n        throw staticError('\\'deps\\' required', provider);\n    }\n    return deps;\n}\nfunction formatError(text, obj, source) {\n    if (source === void 0) { source = null; }\n    text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;\n    var context = stringify(obj);\n    if (obj instanceof Array) {\n        context = obj.map(stringify).join(' -> ');\n    }\n    else if (typeof obj === 'object') {\n        var parts = [];\n        for (var key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                var value = obj[key];\n                parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n            }\n        }\n        context = \"{\" + parts.join(', ') + \"}\";\n    }\n    return \"StaticInjectorError\" + (source ? '(' + source + ')' : '') + \"[\" + context + \"]: \" + text.replace(NEW_LINE, '\\n  ');\n}\nfunction staticError(text, obj) {\n    return new Error(formatError(text, obj));\n}\nfunction getClosureSafeProperty$1(objWithPropertyToExtract) {\n    for (var key in objWithPropertyToExtract) {\n        if (objWithPropertyToExtract[key] === GET_PROPERTY_NAME$1) {\n            return key;\n        }\n    }\n    throw Error('!prop');\n}\n/**\n * Current injector value used by `inject`.\n * - `undefined`: it is an error to call `inject`\n * - `null`: `inject` can be called but there is no injector (limp-mode).\n * - Injector instance: Use the injector for resolution.\n */\nvar _currentInjector = undefined;\nfunction setCurrentInjector(injector) {\n    var former = _currentInjector;\n    _currentInjector = injector;\n    return former;\n}\nfunction inject(token, flags) {\n    if (flags === void 0) { flags = 0 /* Default */; }\n    if (_currentInjector === undefined) {\n        throw new Error(\"inject() must be called from an injection context\");\n    }\n    else if (_currentInjector === null) {\n        var injectableDef = token.ngInjectableDef;\n        if (injectableDef && injectableDef.providedIn == 'root') {\n            return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :\n                injectableDef.value;\n        }\n        throw new Error(\"Injector: NOT_FOUND [\" + stringify(token) + \"]\");\n    }\n    else {\n        return _currentInjector.get(token, flags & 8 /* Optional */ ? null : undefined, flags);\n    }\n}\nfunction injectArgs(types) {\n    var args = [];\n    for (var i = 0; i < types.length; i++) {\n        var arg = types[i];\n        if (Array.isArray(arg)) {\n            if (arg.length === 0) {\n                throw new Error('Arguments array must have arguments.');\n            }\n            var type = undefined;\n            var flags = 0;\n            for (var j = 0; j < arg.length; j++) {\n                var meta = arg[j];\n                if (meta instanceof Optional || meta.__proto__.ngMetadataName === 'Optional') {\n                    flags |= 8 /* Optional */;\n                }\n                else if (meta instanceof SkipSelf || meta.__proto__.ngMetadataName === 'SkipSelf') {\n                    flags |= 4 /* SkipSelf */;\n                }\n                else if (meta instanceof Self || meta.__proto__.ngMetadataName === 'Self') {\n                    flags |= 2 /* Self */;\n                }\n                else if (meta instanceof Inject) {\n                    type = meta.token;\n                }\n                else {\n                    type = meta;\n                }\n            }\n            args.push(inject(type, flags));\n        }\n        else {\n            args.push(inject(arg));\n        }\n    }\n    return args;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar GET_PROPERTY_NAME = {};\nvar ɵ0 = GET_PROPERTY_NAME;\nvar USE_VALUE = getClosureSafeProperty({ provide: String, useValue: ɵ0 }, GET_PROPERTY_NAME);\nvar EMPTY_ARRAY = [];\nfunction convertInjectableProviderToFactory(type, provider) {\n    if (!provider) {\n        var reflectionCapabilities = new ReflectionCapabilities();\n        var deps_1 = reflectionCapabilities.parameters(type);\n        // TODO - convert to flags.\n        return function () { return new (type.bind.apply(type, __spread([void 0], injectArgs(deps_1))))(); };\n    }\n    if (USE_VALUE in provider) {\n        var valueProvider_1 = provider;\n        return function () { return valueProvider_1.useValue; };\n    }\n    else if (provider.useExisting) {\n        var existingProvider_1 = provider;\n        return function () { return inject(existingProvider_1.useExisting); };\n    }\n    else if (provider.useFactory) {\n        var factoryProvider_1 = provider;\n        return function () { return factoryProvider_1.useFactory.apply(factoryProvider_1, __spread(injectArgs(factoryProvider_1.deps || EMPTY_ARRAY))); };\n    }\n    else if (provider.useClass) {\n        var classProvider_1 = provider;\n        var deps_2 = provider.deps;\n        if (!deps_2) {\n            var reflectionCapabilities = new ReflectionCapabilities();\n            deps_2 = reflectionCapabilities.parameters(type);\n        }\n        return function () {\n            return new ((_a = classProvider_1.useClass).bind.apply(_a, __spread([void 0], injectArgs(deps_2))))();\n            var _a;\n        };\n    }\n    else {\n        var deps_3 = provider.deps;\n        if (!deps_3) {\n            var reflectionCapabilities = new ReflectionCapabilities();\n            deps_3 = reflectionCapabilities.parameters(type);\n        }\n        return function () { return new (type.bind.apply(type, __spread([void 0], injectArgs(deps_3))))(); };\n    }\n}\n/**\n* Injectable decorator and metadata.\n*\n* @Annotation\n*/\nvar Injectable = makeDecorator('Injectable', undefined, undefined, undefined, function (injectableType, options) {\n    if (options && options.providedIn !== undefined &&\n        injectableType.ngInjectableDef === undefined) {\n        injectableType.ngInjectableDef = defineInjectable({\n            providedIn: options.providedIn,\n            factory: convertInjectableProviderToFactory(injectableType, options)\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 * Defines a schema that allows an NgModule to contain the following:\n * - Non-Angular elements named with dash case (`-`).\n * - Element properties named with dash case (`-`).\n * Dash case is the naming convention for custom elements.\n *\n *\n */\nvar CUSTOM_ELEMENTS_SCHEMA = {\n    name: 'custom-elements'\n};\n/**\n * Defines a schema that allows any property on any element.\n *\n * @experimental\n */\nvar NO_ERRORS_SCHEMA = {\n    name: 'no-errors-schema'\n};\n/**\n * Decorator that marks the following class as an NgModule, and supplies\n * configuration metadata for it.\n *\n * @Annotation\n */\nvar NgModule = makeDecorator('NgModule', function (ngModule) { return ngModule; }, undefined, undefined, \n/**\n * Decorator that marks the following class as an NgModule, and supplies\n * configuration metadata for it.\n */\nfunction (moduleType, metadata) {\n    var imports = (metadata && metadata.imports) || [];\n    if (metadata && metadata.exports) {\n        imports = __spread(imports, [metadata.exports]);\n    }\n    moduleType.ngInjectorDef = defineInjector({\n        factory: convertInjectableProviderToFactory(moduleType, { useClass: moduleType }),\n        providers: metadata && metadata.providers,\n        imports: imports,\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 * Defines template and style encapsulation options available for Component's {@link Component}.\n *\n * See {@link Component#encapsulation encapsulation}.\n *\n */\n\n(function (ViewEncapsulation) {\n    /**\n     * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host\n     * Element and pre-processing the style rules provided via {@link Component#styles styles} or\n     * {@link Component#styleUrls styleUrls}, and adding the new Host Element attribute to all\n     * selectors.\n     *\n     * This is the default option.\n     */\n    ViewEncapsulation[ViewEncapsulation[\"Emulated\"] = 0] = \"Emulated\";\n    /**\n     * Use the native encapsulation mechanism of the renderer.\n     *\n     * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n     * creating a ShadowRoot for Component's Host Element.\n     */\n    ViewEncapsulation[ViewEncapsulation[\"Native\"] = 1] = \"Native\";\n    /**\n     * Don't provide any template or style encapsulation.\n     */\n    ViewEncapsulation[ViewEncapsulation[\"None\"] = 2] = \"None\";\n})(exports.ViewEncapsulation || (exports.ViewEncapsulation = {}));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @description Represents the version of Angular\n *\n *\n */\nvar Version = /** @class */ (function () {\n    function Version(full) {\n        this.full = full;\n        this.major = full.split('.')[0];\n        this.minor = full.split('.')[1];\n        this.patch = full.split('.').slice(2).join('.');\n    }\n    return Version;\n}());\nvar VERSION = new Version('6.0.7');\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nvar ERROR_DEBUG_CONTEXT = 'ngDebugContext';\nvar ERROR_ORIGINAL_ERROR = 'ngOriginalError';\nvar ERROR_LOGGER = 'ngErrorLogger';\n\nfunction getDebugContext(error) {\n    return error[ERROR_DEBUG_CONTEXT];\n}\nfunction getOriginalError(error) {\n    return error[ERROR_ORIGINAL_ERROR];\n}\nfunction getErrorLogger(error) {\n    return error[ERROR_LOGGER] || defaultErrorLogger;\n}\nfunction defaultErrorLogger(console) {\n    var values = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        values[_i - 1] = arguments[_i];\n    }\n    console.error.apply(console, __spread(values));\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 * Provides a hook for centralized exception handling.\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 * @usageNotes\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 */\nvar ErrorHandler = /** @class */ (function () {\n    function ErrorHandler() {\n        /**\n         * @internal\n         */\n        this._console = console;\n    }\n    ErrorHandler.prototype.handleError = function (error) {\n        var originalError = this._findOriginalError(error);\n        var 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        var errorLogger = getErrorLogger(error);\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    /** @internal */\n    ErrorHandler.prototype._findContext = function (error) {\n        if (error) {\n            return getDebugContext(error) ? getDebugContext(error) :\n                this._findContext(getOriginalError(error));\n        }\n        return null;\n    };\n    /** @internal */\n    ErrorHandler.prototype._findOriginalError = function (error) {\n        var e = getOriginalError(error);\n        while (e && getOriginalError(e)) {\n            e = getOriginalError(e);\n        }\n        return e;\n    };\n    return ErrorHandler;\n}());\nfunction wrappedError(message, originalError) {\n    var msg = message + \" caused by: \" + (originalError instanceof Error ? originalError.message : originalError);\n    var error = Error(msg);\n    error[ERROR_ORIGINAL_ERROR] = originalError;\n    return error;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction findFirstClosedCycle(keys) {\n    var res = [];\n    for (var 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}\nfunction constructResolvingPath(keys) {\n    if (keys.length > 1) {\n        var reversed = findFirstClosedCycle(keys.slice().reverse());\n        var tokenStrs = reversed.map(function (k) { return stringify(k.token); });\n        return ' (' + tokenStrs.join(' -> ') + ')';\n    }\n    return '';\n}\nfunction injectionError(injector, key, constructResolvingMessage, originalError) {\n    var keys = [key];\n    var errMsg = constructResolvingMessage(keys);\n    var error = (originalError ? wrappedError(errMsg, originalError) : Error(errMsg));\n    error.addKey = addKey;\n    error.keys = keys;\n    error.injectors = [injector];\n    error.constructResolvingMessage = constructResolvingMessage;\n    error[ERROR_ORIGINAL_ERROR] = originalError;\n    return error;\n}\nfunction addKey(injector, key) {\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 * @usageNotes\n * ### Example\n *\n * ```typescript\n * class A {\n *   constructor(b:B) {}\n * }\n *\n * expect(() => Injector.resolveAndCreate([A])).toThrowError();\n * ```\n */\nfunction noProviderError(injector, key) {\n    return injectionError(injector, key, function (keys) {\n        var 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 * @usageNotes\n * ### Example\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 */\nfunction cyclicDependencyError(injector, key) {\n    return injectionError(injector, key, function (keys) {\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 * @usageNotes\n * ### Example\n *\n * ```typescript\n * class A {\n *   constructor() {\n *     throw new Error('message');\n *   }\n * }\n *\n * var injector = Injector.resolveAndCreate([A]);\n\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 */\nfunction instantiationError(injector, originalException, originalStack, key) {\n    return injectionError(injector, key, function (keys) {\n        var 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 * @usageNotes\n * ### Example\n *\n * ```typescript\n * expect(() => Injector.resolveAndCreate([\"not a type\"])).toThrowError();\n * ```\n */\nfunction invalidProviderError(provider) {\n    return Error(\"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 * @usageNotes\n * ### Example\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 *\n */\nfunction noAnnotationError(typeOrFunc, params) {\n    var signature = [];\n    for (var i = 0, ii = params.length; i < ii; i++) {\n        var parameter = params[i];\n        if (!parameter || parameter.length == 0) {\n            signature.push('?');\n        }\n        else {\n            signature.push(parameter.map(stringify).join(' '));\n        }\n    }\n    return Error('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 * @usageNotes\n * ### Example\n *\n * ```typescript\n * class A {}\n *\n * var injector = Injector.resolveAndCreate([A]);\n *\n * expect(() => injector.getAt(100)).toThrowError();\n * ```\n *\n */\nfunction outOfBoundsError(index) {\n    return Error(\"Index \" + index + \" is out-of-bounds.\");\n}\n// TODO: add a working example after alpha38 is released\n/**\n * Thrown when a multi provider and a regular provider are bound to the same token.\n *\n * @usageNotes\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 */\nfunction mixingMultiProvidersWithRegularProvidersError(provider1, provider2) {\n    return Error(\"Cannot mix multi providers and regular providers, got: \" + provider1 + \" \" + provider2);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A 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 * @deprecated No replacement\n */\nvar ReflectiveKey = /** @class */ (function () {\n    /**\n     * Private\n     */\n    function ReflectiveKey(token, id) {\n        this.token = token;\n        this.id = id;\n        if (!token) {\n            throw new Error('Token must be defined!');\n        }\n        this.displayName = stringify(this.token);\n    }\n    /**\n     * Retrieves a `Key` for a token.\n     */\n    ReflectiveKey.get = function (token) {\n        return _globalKeyRegistry.get(resolveForwardRef(token));\n    };\n    Object.defineProperty(ReflectiveKey, \"numberOfKeys\", {\n        /**\n         * @returns the number of keys registered in the system.\n         */\n        get: function () { return _globalKeyRegistry.numberOfKeys; },\n        enumerable: true,\n        configurable: true\n    });\n    return ReflectiveKey;\n}());\nvar KeyRegistry = /** @class */ (function () {\n    function KeyRegistry() {\n        this._allKeys = new Map();\n    }\n    KeyRegistry.prototype.get = function (token) {\n        if (token instanceof ReflectiveKey)\n            return token;\n        if (this._allKeys.has(token)) {\n            return this._allKeys.get(token);\n        }\n        var newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);\n        this._allKeys.set(token, newKey);\n        return newKey;\n    };\n    Object.defineProperty(KeyRegistry.prototype, \"numberOfKeys\", {\n        get: function () { return this._allKeys.size; },\n        enumerable: true,\n        configurable: true\n    });\n    return KeyRegistry;\n}());\nvar _globalKeyRegistry = new KeyRegistry();\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 * Provides access to reflection data about symbols. Used internally by Angular\n * to power dependency injection and compilation.\n */\nvar Reflector = /** @class */ (function () {\n    function Reflector(reflectionCapabilities) {\n        this.reflectionCapabilities = reflectionCapabilities;\n    }\n    Reflector.prototype.updateCapabilities = function (caps) { this.reflectionCapabilities = caps; };\n    Reflector.prototype.factory = function (type) { return this.reflectionCapabilities.factory(type); };\n    Reflector.prototype.parameters = function (typeOrFunc) {\n        return this.reflectionCapabilities.parameters(typeOrFunc);\n    };\n    Reflector.prototype.annotations = function (typeOrFunc) {\n        return this.reflectionCapabilities.annotations(typeOrFunc);\n    };\n    Reflector.prototype.propMetadata = function (typeOrFunc) {\n        return this.reflectionCapabilities.propMetadata(typeOrFunc);\n    };\n    Reflector.prototype.hasLifecycleHook = function (type, lcProperty) {\n        return this.reflectionCapabilities.hasLifecycleHook(type, lcProperty);\n    };\n    Reflector.prototype.getter = function (name) { return this.reflectionCapabilities.getter(name); };\n    Reflector.prototype.setter = function (name) { return this.reflectionCapabilities.setter(name); };\n    Reflector.prototype.method = function (name) { return this.reflectionCapabilities.method(name); };\n    Reflector.prototype.importUri = function (type) { return this.reflectionCapabilities.importUri(type); };\n    Reflector.prototype.resourceUri = function (type) { return this.reflectionCapabilities.resourceUri(type); };\n    Reflector.prototype.resolveIdentifier = function (name, moduleUrl, members, runtime) {\n        return this.reflectionCapabilities.resolveIdentifier(name, moduleUrl, members, runtime);\n    };\n    Reflector.prototype.resolveEnum = function (identifier, name) {\n        return this.reflectionCapabilities.resolveEnum(identifier, name);\n    };\n    return Reflector;\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 * The {@link Reflector} used internally in Angular to access metadata\n * about symbols.\n */\nvar reflector = new Reflector(new ReflectionCapabilities());\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 * `Dependency` is used by the framework to extend DI.\n * This is internal to Angular and should not be used directly.\n */\nvar ReflectiveDependency = /** @class */ (function () {\n    function ReflectiveDependency(key, optional, visibility) {\n        this.key = key;\n        this.optional = optional;\n        this.visibility = visibility;\n    }\n    ReflectiveDependency.fromKey = function (key) {\n        return new ReflectiveDependency(key, false, null);\n    };\n    return ReflectiveDependency;\n}());\nvar _EMPTY_LIST = [];\nvar ResolvedReflectiveProvider_ = /** @class */ (function () {\n    function ResolvedReflectiveProvider_(key, resolvedFactories, multiProvider) {\n        this.key = key;\n        this.resolvedFactories = resolvedFactories;\n        this.multiProvider = multiProvider;\n        this.resolvedFactory = this.resolvedFactories[0];\n    }\n    return ResolvedReflectiveProvider_;\n}());\n/**\n * An internal resolved representation of a factory function created by resolving `Provider`.\n * @experimental\n */\nvar ResolvedReflectiveFactory = /** @class */ (function () {\n    function ResolvedReflectiveFactory(\n    /**\n     * Factory function which can return an instance of an object represented by a key.\n     */\n    factory, \n    /**\n     * Arguments (dependencies) to the `factory` function.\n     */\n    dependencies) {\n        this.factory = factory;\n        this.dependencies = dependencies;\n    }\n    return ResolvedReflectiveFactory;\n}());\n/**\n * Resolve a single provider.\n */\nfunction resolveReflectiveFactory(provider) {\n    var factoryFn;\n    var resolvedDeps;\n    if (provider.useClass) {\n        var useClass = resolveForwardRef(provider.useClass);\n        factoryFn = reflector.factory(useClass);\n        resolvedDeps = _dependenciesFor(useClass);\n    }\n    else if (provider.useExisting) {\n        factoryFn = function (aliasInstance) { return aliasInstance; };\n        resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];\n    }\n    else if (provider.useFactory) {\n        factoryFn = provider.useFactory;\n        resolvedDeps = constructDependencies(provider.useFactory, provider.deps);\n    }\n    else {\n        factoryFn = function () { return provider.useValue; };\n        resolvedDeps = _EMPTY_LIST;\n    }\n    return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);\n}\n/**\n * Converts the `Provider` into `ResolvedProvider`.\n *\n * `Injector` internally only uses `ResolvedProvider`, `Provider` contains convenience provider\n * syntax.\n */\nfunction resolveReflectiveProvider(provider) {\n    return new ResolvedReflectiveProvider_(ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)], provider.multi || false);\n}\n/**\n * Resolve a list of Providers.\n */\nfunction resolveReflectiveProviders(providers) {\n    var normalized = _normalizeProviders(providers, []);\n    var resolved = normalized.map(resolveReflectiveProvider);\n    var resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());\n    return Array.from(resolvedProviderMap.values());\n}\n/**\n * Merges a list of ResolvedProviders into a list where each key is contained exactly once and\n * multi providers have been merged.\n */\nfunction mergeResolvedReflectiveProviders(providers, normalizedProvidersMap) {\n    for (var i = 0; i < providers.length; i++) {\n        var provider = providers[i];\n        var 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 (var j = 0; j < provider.resolvedFactories.length; j++) {\n                    existing.resolvedFactories.push(provider.resolvedFactories[j]);\n                }\n            }\n            else {\n                normalizedProvidersMap.set(provider.key.id, provider);\n            }\n        }\n        else {\n            var resolvedProvider = void 0;\n            if (provider.multiProvider) {\n                resolvedProvider = new ResolvedReflectiveProvider_(provider.key, provider.resolvedFactories.slice(), provider.multiProvider);\n            }\n            else {\n                resolvedProvider = provider;\n            }\n            normalizedProvidersMap.set(provider.key.id, resolvedProvider);\n        }\n    }\n    return normalizedProvidersMap;\n}\nfunction _normalizeProviders(providers, res) {\n    providers.forEach(function (b) {\n        if (b instanceof Type) {\n            res.push({ provide: b, useClass: b });\n        }\n        else if (b && typeof b == 'object' && b.provide !== undefined) {\n            res.push(b);\n        }\n        else if (b instanceof Array) {\n            _normalizeProviders(b, res);\n        }\n        else {\n            throw invalidProviderError(b);\n        }\n    });\n    return res;\n}\nfunction constructDependencies(typeOrFunc, dependencies) {\n    if (!dependencies) {\n        return _dependenciesFor(typeOrFunc);\n    }\n    else {\n        var params_1 = dependencies.map(function (t) { return [t]; });\n        return dependencies.map(function (t) { return _extractToken(typeOrFunc, t, params_1); });\n    }\n}\nfunction _dependenciesFor(typeOrFunc) {\n    var params = reflector.parameters(typeOrFunc);\n    if (!params)\n        return [];\n    if (params.some(function (p) { return p == null; })) {\n        throw noAnnotationError(typeOrFunc, params);\n    }\n    return params.map(function (p) { return _extractToken(typeOrFunc, p, params); });\n}\nfunction _extractToken(typeOrFunc, metadata, params) {\n    var token = null;\n    var optional = false;\n    if (!Array.isArray(metadata)) {\n        if (metadata instanceof Inject) {\n            return _createDependency(metadata.token, optional, null);\n        }\n        else {\n            return _createDependency(metadata, optional, null);\n        }\n    }\n    var visibility = null;\n    for (var i = 0; i < metadata.length; ++i) {\n        var paramMetadata = metadata[i];\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        }\n        else if (paramMetadata instanceof InjectionToken) {\n            token = paramMetadata;\n        }\n    }\n    token = resolveForwardRef(token);\n    if (token != null) {\n        return _createDependency(token, optional, visibility);\n    }\n    else {\n        throw noAnnotationError(typeOrFunc, params);\n    }\n}\nfunction _createDependency(token, optional, visibility) {\n    return new ReflectiveDependency(ReflectiveKey.get(token), optional, visibility);\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// Threshold for the dynamic version\nvar 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 * @usageNotes\n * ### Example\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 * @deprecated from v5 - slow and brings in a lot of code, Use `Injector.create` instead.\n */\nvar ReflectiveInjector = /** @class */ (function () {\n    function ReflectiveInjector() {\n    }\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 `ResolvedReflectiveProvider`s.\n     *\n     * @usageNotes\n     * ### Example\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     */\n    ReflectiveInjector.resolve = function (providers) {\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`, `Provider`,\n     * or a recursive array of more providers.\n     *\n     * @usageNotes\n     * ### Example\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    ReflectiveInjector.resolveAndCreate = function (providers, parent) {\n        var 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     * @usageNotes\n     * ### Example\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     */\n    ReflectiveInjector.fromResolvedProviders = function (providers, parent) {\n        return new ReflectiveInjector_(providers, parent);\n    };\n    return ReflectiveInjector;\n}());\nvar ReflectiveInjector_ = /** @class */ (function () {\n    /**\n     * Private\n     */\n    function ReflectiveInjector_(_providers, _parent) {\n        /** @internal */\n        this._constructionCounter = 0;\n        this._providers = _providers;\n        this.parent = _parent || null;\n        var len = _providers.length;\n        this.keyIds = new Array(len);\n        this.objs = new Array(len);\n        for (var i = 0; i < len; i++) {\n            this.keyIds[i] = _providers[i].key.id;\n            this.objs[i] = UNDEFINED;\n        }\n    }\n    ReflectiveInjector_.prototype.get = function (token, notFoundValue) {\n        if (notFoundValue === void 0) { notFoundValue = THROW_IF_NOT_FOUND; }\n        return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);\n    };\n    ReflectiveInjector_.prototype.resolveAndCreateChild = function (providers) {\n        var ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);\n        return this.createChildFromResolved(ResolvedReflectiveProviders);\n    };\n    ReflectiveInjector_.prototype.createChildFromResolved = function (providers) {\n        var inj = new ReflectiveInjector_(providers);\n        inj.parent = this;\n        return inj;\n    };\n    ReflectiveInjector_.prototype.resolveAndInstantiate = function (provider) {\n        return this.instantiateResolved(ReflectiveInjector.resolve([provider])[0]);\n    };\n    ReflectiveInjector_.prototype.instantiateResolved = function (provider) {\n        return this._instantiateProvider(provider);\n    };\n    ReflectiveInjector_.prototype.getProviderAtIndex = function (index) {\n        if (index < 0 || index >= this._providers.length) {\n            throw outOfBoundsError(index);\n        }\n        return this._providers[index];\n    };\n    /** @internal */\n    ReflectiveInjector_.prototype._new = function (provider) {\n        if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {\n            throw cyclicDependencyError(this, provider.key);\n        }\n        return this._instantiateProvider(provider);\n    };\n    ReflectiveInjector_.prototype._getMaxNumberOfObjects = function () { return this.objs.length; };\n    ReflectiveInjector_.prototype._instantiateProvider = function (provider) {\n        if (provider.multiProvider) {\n            var res = new Array(provider.resolvedFactories.length);\n            for (var i = 0; i < provider.resolvedFactories.length; ++i) {\n                res[i] = this._instantiate(provider, provider.resolvedFactories[i]);\n            }\n            return res;\n        }\n        else {\n            return this._instantiate(provider, provider.resolvedFactories[0]);\n        }\n    };\n    ReflectiveInjector_.prototype._instantiate = function (provider, ResolvedReflectiveFactory$$1) {\n        var _this = this;\n        var factory = ResolvedReflectiveFactory$$1.factory;\n        var deps;\n        try {\n            deps =\n                ResolvedReflectiveFactory$$1.dependencies.map(function (dep) { return _this._getByReflectiveDependency(dep); });\n        }\n        catch (e) {\n            if (e.addKey) {\n                e.addKey(this, provider.key);\n            }\n            throw e;\n        }\n        var obj;\n        try {\n            obj = factory.apply(void 0, __spread(deps));\n        }\n        catch (e) {\n            throw instantiationError(this, e, e.stack, provider.key);\n        }\n        return obj;\n    };\n    ReflectiveInjector_.prototype._getByReflectiveDependency = function (dep) {\n        return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);\n    };\n    ReflectiveInjector_.prototype._getByKey = function (key, visibility, notFoundValue) {\n        if (key === ReflectiveInjector_.INJECTOR_KEY) {\n            return this;\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    ReflectiveInjector_.prototype._getObjByKeyId = function (keyId) {\n        for (var 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                return this.objs[i];\n            }\n        }\n        return UNDEFINED;\n    };\n    /** @internal */\n    ReflectiveInjector_.prototype._throwOrNull = function (key, notFoundValue) {\n        if (notFoundValue !== THROW_IF_NOT_FOUND) {\n            return notFoundValue;\n        }\n        else {\n            throw noProviderError(this, key);\n        }\n    };\n    /** @internal */\n    ReflectiveInjector_.prototype._getByKeySelf = function (key, notFoundValue) {\n        var obj = this._getObjByKeyId(key.id);\n        return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);\n    };\n    /** @internal */\n    ReflectiveInjector_.prototype._getByKeyDefault = function (key, notFoundValue, visibility) {\n        var inj;\n        if (visibility instanceof SkipSelf) {\n            inj = this.parent;\n        }\n        else {\n            inj = this;\n        }\n        while (inj instanceof ReflectiveInjector_) {\n            var inj_ = inj;\n            var obj = inj_._getObjByKeyId(key.id);\n            if (obj !== UNDEFINED)\n                return obj;\n            inj = inj_.parent;\n        }\n        if (inj !== null) {\n            return inj.get(key.token, notFoundValue);\n        }\n        else {\n            return this._throwOrNull(key, notFoundValue);\n        }\n    };\n    Object.defineProperty(ReflectiveInjector_.prototype, \"displayName\", {\n        get: function () {\n            var providers = _mapProviders(this, function (b) { return ' \"' + b.key.displayName + '\" '; })\n                .join(', ');\n            return \"ReflectiveInjector(providers: [\" + providers + \"])\";\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ReflectiveInjector_.prototype.toString = function () { return this.displayName; };\n    ReflectiveInjector_.INJECTOR_KEY = ReflectiveKey.get(Injector);\n    return ReflectiveInjector_;\n}());\nfunction _mapProviders(injector, fn) {\n    var res = new Array(injector._providers.length);\n    for (var i = 0; i < injector._providers.length; ++i) {\n        res[i] = fn(injector.getProviderAtIndex(i));\n    }\n    return res;\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 * An internal token whose presence in an injector indicates that the injector should treat itself\n * as a root scoped injector when processing requests for unknown tokens which may indicate\n * they are provided in the root scope.\n */\nvar APP_ROOT = new InjectionToken('The presence of this token marks an injector as being the root injector.');\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 * Marker which indicates that a value has not yet been created from the factory function.\n */\nvar NOT_YET = {};\n/**\n * Marker which indicates that the factory function for a token is in the process of being called.\n *\n * If the injector is asked to inject a token with its value set to CIRCULAR, that indicates\n * injection of a dependency has recursively attempted to inject the original token, and there is\n * a circular dependency among the providers.\n */\nvar CIRCULAR$1 = {};\nvar EMPTY_ARRAY$1 = [];\n/**\n * A lazily initialized NullInjector.\n */\nvar NULL_INJECTOR$1 = undefined;\nfunction getNullInjector() {\n    if (NULL_INJECTOR$1 === undefined) {\n        NULL_INJECTOR$1 = new NullInjector();\n    }\n    return NULL_INJECTOR$1;\n}\n/**\n * Create a new `Injector` which is configured using `InjectorType`s.\n *\n * @experimental\n */\nfunction createInjector(defType, parent) {\n    if (parent === void 0) { parent = null; }\n    parent = parent || getNullInjector();\n    return new R3Injector(defType, parent);\n}\nvar R3Injector = /** @class */ (function () {\n    function R3Injector(def, parent) {\n        var _this = this;\n        this.parent = parent;\n        /**\n         * Map of tokens to records which contain the instances of those tokens.\n         */\n        this.records = new Map();\n        /**\n         * The transitive set of `InjectorType`s which define this injector.\n         */\n        this.injectorDefTypes = new Set();\n        /**\n         * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.\n         */\n        this.onDestroy = new Set();\n        /**\n         * Flag indicating that this injector was previously destroyed.\n         */\n        this.destroyed = false;\n        // Start off by creating Records for every provider declared in every InjectorType\n        // included transitively in `def`.\n        deepForEach([def], function (injectorDef) { return _this.processInjectorType(injectorDef, new Set()); });\n        // Make sure the INJECTOR token provides this injector.\n        this.records.set(INJECTOR, makeRecord(undefined, this));\n        // Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide\n        // any injectable scoped to APP_ROOT_SCOPE.\n        this.isRootInjector = this.records.has(APP_ROOT);\n        // Eagerly instantiate the InjectorType classes themselves.\n        this.injectorDefTypes.forEach(function (defType) { return _this.get(defType); });\n    }\n    /**\n     * Destroy the injector and release references to every instance or provider associated with it.\n     *\n     * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a\n     * hook was found.\n     */\n    R3Injector.prototype.destroy = function () {\n        this.assertNotDestroyed();\n        // Set destroyed = true first, in case lifecycle hooks re-enter destroy().\n        this.destroyed = true;\n        try {\n            // Call all the lifecycle hooks.\n            this.onDestroy.forEach(function (service) { return service.ngOnDestroy(); });\n        }\n        finally {\n            // Release all references.\n            this.records.clear();\n            this.onDestroy.clear();\n            this.injectorDefTypes.clear();\n        }\n    };\n    R3Injector.prototype.get = function (token, notFoundValue, flags) {\n        if (notFoundValue === void 0) { notFoundValue = THROW_IF_NOT_FOUND; }\n        if (flags === void 0) { flags = 0 /* Default */; }\n        this.assertNotDestroyed();\n        // Set the injection context.\n        var previousInjector = setCurrentInjector(this);\n        try {\n            // Check for the SkipSelf flag.\n            if (!(flags & 4 /* SkipSelf */)) {\n                // SkipSelf isn't set, check if the record belongs to this injector.\n                var record = this.records.get(token);\n                if (record === undefined) {\n                    // No record, but maybe the token is scoped to this injector. Look for an ngInjectableDef\n                    // with a scope matching this injector.\n                    var def = couldBeInjectableType(token) &&\n                        token.ngInjectableDef ||\n                        undefined;\n                    if (def !== undefined && this.injectableDefInScope(def)) {\n                        // Found an ngInjectableDef and it's scoped to this injector. Pretend as if it was here\n                        // all along.\n                        record = injectableDefRecord(token);\n                        this.records.set(token, record);\n                    }\n                }\n                // If a record was found, get the instance for it and return it.\n                if (record !== undefined) {\n                    return this.hydrate(token, record);\n                }\n            }\n            // Select the next injector based on the Self flag - if self is set, the next injector is\n            // the NullInjector, otherwise it's the parent.\n            var next = !(flags & 2 /* Self */) ? this.parent : getNullInjector();\n            return this.parent.get(token, notFoundValue);\n        }\n        finally {\n            // Lastly, clean up the state by restoring the previous injector.\n            setCurrentInjector(previousInjector);\n        }\n    };\n    R3Injector.prototype.assertNotDestroyed = function () {\n        if (this.destroyed) {\n            throw new Error('Injector has already been destroyed.');\n        }\n    };\n    /**\n     * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers\n     * to this injector.\n     */\n    R3Injector.prototype.processInjectorType = function (defOrWrappedDef, parents) {\n        var _this = this;\n        defOrWrappedDef = resolveForwardRef(defOrWrappedDef);\n        // Either the defOrWrappedDef is an InjectorType (with ngInjectorDef) or an\n        // InjectorDefTypeWithProviders (aka ModuleWithProviders). Detecting either is a megamorphic\n        // read, so care is taken to only do the read once.\n        // First attempt to read the ngInjectorDef.\n        var def = defOrWrappedDef.ngInjectorDef;\n        // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.\n        var ngModule = (def == null) && defOrWrappedDef.ngModule || undefined;\n        // Determine the InjectorType. In the case where `defOrWrappedDef` is an `InjectorType`,\n        // then this is easy. In the case of an InjectorDefTypeWithProviders, then the definition type\n        // is the `ngModule`.\n        var defType = (ngModule === undefined) ? defOrWrappedDef : ngModule;\n        // If defOrWrappedType was an InjectorDefTypeWithProviders, then .providers may hold some\n        // extra providers.\n        var providers = (ngModule !== undefined) && defOrWrappedDef.providers ||\n            EMPTY_ARRAY$1;\n        // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual\n        // `InjectorDef` is on its `ngModule`.\n        if (ngModule !== undefined) {\n            def = ngModule.ngInjectorDef;\n        }\n        // If no definition was found, throw.\n        if (def == null) {\n            throw new Error(\"Type \" + stringify(defType) + \" is missing an ngInjectorDef definition.\");\n        }\n        // Check for circular dependencies.\n        if (parents.has(defType)) {\n            throw new Error(\"Circular dependency: type \" + stringify(defType) + \" ends up importing itself.\");\n        }\n        // Track the InjectorType and add a provider for it.\n        this.injectorDefTypes.add(defType);\n        this.records.set(defType, makeRecord(def.factory));\n        // Add providers in the same way that @NgModule resolution did:\n        // First, include providers from any imports.\n        if (def.imports != null) {\n            // Before processing defType's imports, add it to the set of parents. This way, if it ends\n            // up deeply importing itself, this can be detected.\n            parents.add(defType);\n            try {\n                deepForEach(def.imports, function (imported) { return _this.processInjectorType(imported, parents); });\n            }\n            finally {\n                // Remove it from the parents set when finished.\n                parents.delete(defType);\n            }\n        }\n        // Next, include providers listed on the definition itself.\n        if (def.providers != null) {\n            deepForEach(def.providers, function (provider) { return _this.processProvider(provider); });\n        }\n        // Finally, include providers from an InjectorDefTypeWithProviders if there was one.\n        deepForEach(providers, function (provider) { return _this.processProvider(provider); });\n    };\n    /**\n     * Process a `SingleProvider` and add it.\n     */\n    R3Injector.prototype.processProvider = function (provider) {\n        // Determine the token from the provider. Either it's its own token, or has a {provide: ...}\n        // property.\n        provider = resolveForwardRef(provider);\n        var token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);\n        // Construct a `Record` for the provider.\n        var record = providerToRecord(provider);\n        if (!isTypeProvider(provider) && provider.multi === true) {\n            // If the provider indicates that it's a multi-provider, process it specially.\n            // First check whether it's been defined already.\n            var multiRecord_1 = this.records.get(token);\n            if (multiRecord_1) {\n                // It has. Throw a nice error if\n                if (multiRecord_1.multi === undefined) {\n                    throw new Error(\"Mixed multi-provider for \" + token + \".\");\n                }\n            }\n            else {\n                token = provider;\n                multiRecord_1 = makeRecord(undefined, NOT_YET, true);\n                multiRecord_1.factory = function () { return injectArgs(multiRecord_1.multi); };\n                this.records.set(token, multiRecord_1);\n            }\n            token = provider;\n            multiRecord_1.multi.push(provider);\n        }\n        var existing = this.records.get(token);\n        if (existing && existing.multi !== undefined) {\n            throw new Error(\"Mixed multi-provider for \" + token);\n        }\n        this.records.set(token, record);\n    };\n    R3Injector.prototype.hydrate = function (token, record) {\n        if (record.value === CIRCULAR$1) {\n            throw new Error(\"Circular dep for \" + stringify(token));\n        }\n        else if (record.value === NOT_YET) {\n            record.value = CIRCULAR$1;\n            record.value = record.factory();\n        }\n        if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {\n            this.onDestroy.add(record.value);\n        }\n        return record.value;\n    };\n    R3Injector.prototype.injectableDefInScope = function (def) {\n        if (!def.providedIn) {\n            return false;\n        }\n        else if (typeof def.providedIn === 'string') {\n            return def.providedIn === 'any' || (def.providedIn === 'root' && this.isRootInjector);\n        }\n        else {\n            return this.injectorDefTypes.has(def.providedIn);\n        }\n    };\n    return R3Injector;\n}());\nfunction injectableDefRecord(token) {\n    var def = token.ngInjectableDef;\n    if (def === undefined) {\n        throw new Error(\"Type \" + stringify(token) + \" is missing an ngInjectableDef definition.\");\n    }\n    return makeRecord(def.factory);\n}\nfunction providerToRecord(provider) {\n    var token = resolveForwardRef(provider);\n    var value = NOT_YET;\n    var factory = undefined;\n    if (isTypeProvider(provider)) {\n        return injectableDefRecord(provider);\n    }\n    else {\n        token = resolveForwardRef(provider.provide);\n        if (isValueProvider(provider)) {\n            value = provider.useValue;\n        }\n        else if (isExistingProvider(provider)) {\n            factory = function () { return inject(provider.useExisting); };\n        }\n        else if (isFactoryProvider(provider)) {\n            factory = function () { return provider.useFactory.apply(provider, __spread(injectArgs(provider.deps || []))); };\n        }\n        else {\n            var classRef_1 = provider.useClass || token;\n            if (hasDeps(provider)) {\n                factory = function () { return new ((classRef_1).bind.apply((classRef_1), __spread([void 0], injectArgs(provider.deps))))(); };\n            }\n            else {\n                return injectableDefRecord(classRef_1);\n            }\n        }\n    }\n    return makeRecord(factory, value);\n}\nfunction makeRecord(factory, value, multi) {\n    if (value === void 0) { value = NOT_YET; }\n    if (multi === void 0) { multi = false; }\n    return {\n        factory: factory,\n        value: value,\n        multi: multi ? [] : undefined,\n    };\n}\nfunction deepForEach(input, fn) {\n    input.forEach(function (value) { return Array.isArray(value) ? deepForEach(value, fn) : fn(value); });\n}\nfunction isValueProvider(value) {\n    return USE_VALUE$1 in value;\n}\nfunction isExistingProvider(value) {\n    return !!value.useExisting;\n}\nfunction isFactoryProvider(value) {\n    return !!value.useFactory;\n}\nfunction isTypeProvider(value) {\n    return typeof value === 'function';\n}\nfunction hasDeps(value) {\n    return !!value.deps;\n}\nfunction hasOnDestroy(value) {\n    return typeof value === 'object' && value != null && value.ngOnDestroy &&\n        typeof value.ngOnDestroy === 'function';\n}\nfunction couldBeInjectableType(value) {\n    return (typeof value === 'function') ||\n        (typeof value === 'object' && value instanceof InjectionToken);\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 * @module\n * @description\n * The `di` module provides dependency injection container services.\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Determine if the argument is shaped like a Promise\n */\nfunction isPromise(obj) {\n    // allow any Promise/A+ compliant thenable.\n    // It's up to the caller to ensure that obj.then conforms to the spec\n    return !!obj && typeof obj.then === 'function';\n}\n/**\n * Determine if the argument is an Observable\n */\nfunction isObservable(obj) {\n    // TODO: use Symbol.observable when https://github.com/ReactiveX/rxjs/issues/2415 will be resolved\n    return !!obj && typeof obj.subscribe === 'function';\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A function that will be executed when an application is initialized.\n * @experimental\n */\nvar APP_INITIALIZER = new InjectionToken('Application Initializer');\n/**\n * A class that reflects the state of running {@link APP_INITIALIZER}s.\n *\n * @experimental\n */\nvar ApplicationInitStatus = /** @class */ (function () {\n    function ApplicationInitStatus(appInits) {\n        var _this = this;\n        this.appInits = appInits;\n        this.initialized = false;\n        this.done = false;\n        this.donePromise = new Promise(function (res, rej) {\n            _this.resolve = res;\n            _this.reject = rej;\n        });\n    }\n    /** @internal */\n    ApplicationInitStatus.prototype.runInitializers = function () {\n        var _this = this;\n        if (this.initialized) {\n            return;\n        }\n        var asyncInitPromises = [];\n        var complete = function () {\n            _this.done = true;\n            _this.resolve();\n        };\n        if (this.appInits) {\n            for (var i = 0; i < this.appInits.length; i++) {\n                var initResult = this.appInits[i]();\n                if (isPromise(initResult)) {\n                    asyncInitPromises.push(initResult);\n                }\n            }\n        }\n        Promise.all(asyncInitPromises).then(function () { complete(); }).catch(function (e) { _this.reject(e); });\n        if (asyncInitPromises.length === 0) {\n            complete();\n        }\n        this.initialized = true;\n    };\n    ApplicationInitStatus.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    ApplicationInitStatus.ctorParameters = function () { return [\n        { type: Array, decorators: [{ type: Inject, args: [APP_INITIALIZER,] }, { type: Optional }] }\n    ]; };\n    return ApplicationInitStatus;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A DI Token representing a unique string id assigned to the application by Angular and used\n * primarily for prefixing application attributes and CSS styles when\n * {@link ViewEncapsulation#Emulated ViewEncapsulation.Emulated} is being used.\n *\n * If you need to avoid randomly generated value to be used as an application id, you can provide\n * a custom value via a DI provider <!-- TODO: provider --> configuring the root {@link Injector}\n * using this token.\n * @experimental\n */\nvar APP_ID = new InjectionToken('AppId');\nfunction _appIdRandomProviderFactory() {\n    return \"\" + _randomChar() + _randomChar() + _randomChar();\n}\n/**\n * Providers that will generate a random APP_ID_TOKEN.\n * @experimental\n */\nvar APP_ID_RANDOM_PROVIDER = {\n    provide: APP_ID,\n    useFactory: _appIdRandomProviderFactory,\n    deps: [],\n};\nfunction _randomChar() {\n    return String.fromCharCode(97 + Math.floor(Math.random() * 25));\n}\n/**\n * A function that will be executed when a platform is initialized.\n * @experimental\n */\nvar PLATFORM_INITIALIZER = new InjectionToken('Platform Initializer');\n/**\n * A token that indicates an opaque platform id.\n * @experimental\n */\nvar PLATFORM_ID = new InjectionToken('Platform ID');\n/**\n * All callbacks provided via this token will be called for every component that is bootstrapped.\n * Signature of the callback:\n *\n * `(componentRef: ComponentRef) => void`.\n *\n * @experimental\n */\nvar APP_BOOTSTRAP_LISTENER = new InjectionToken('appBootstrapListener');\n/**\n * A token which indicates the root directory of the application\n * @experimental\n */\nvar PACKAGE_ROOT_URL = new InjectionToken('Application Packages Root URL');\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar Console = /** @class */ (function () {\n    function Console() {\n    }\n    Console.prototype.log = function (message) {\n        // tslint:disable-next-line:no-console\n        console.log(message);\n    };\n    // Note: for reporting errors use `DOM.logError()` as it is platform specific\n    Console.prototype.warn = function (message) {\n        // tslint:disable-next-line:no-console\n        console.warn(message);\n    };\n    Console.decorators = [\n        { type: Injectable }\n    ];\n    return Console;\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 * Combination of NgModuleFactory and ComponentFactorys.\n *\n * @experimental\n */\nvar ModuleWithComponentFactories = /** @class */ (function () {\n    function ModuleWithComponentFactories(ngModuleFactory, componentFactories) {\n        this.ngModuleFactory = ngModuleFactory;\n        this.componentFactories = componentFactories;\n    }\n    return ModuleWithComponentFactories;\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 *\n */\nvar Compiler = /** @class */ (function () {\n    function Compiler() {\n    }\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     */\n    Compiler.prototype.compileModuleSync = function (moduleType) { throw _throwError(); };\n    /**\n     * Compiles the given NgModule and all of its components\n     */\n    Compiler.prototype.compileModuleAsync = function (moduleType) { throw _throwError(); };\n    /**\n     * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n     */\n    Compiler.prototype.compileModuleAndAllComponentsSync = function (moduleType) {\n        throw _throwError();\n    };\n    /**\n     * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n     */\n    Compiler.prototype.compileModuleAndAllComponentsAsync = function (moduleType) {\n        throw _throwError();\n    };\n    /**\n     * Clears all caches.\n     */\n    Compiler.prototype.clearCache = function () { };\n    /**\n     * Clears the cache for the given component/ngModule.\n     */\n    Compiler.prototype.clearCacheFor = function (type) { };\n    Compiler.decorators = [\n        { type: Injectable }\n    ];\n    return Compiler;\n}());\n/**\n * Token to provide CompilerOptions in the platform injector.\n *\n * @experimental\n */\nvar COMPILER_OPTIONS = new InjectionToken('compilerOptions');\n/**\n * A factory for creating a Compiler\n *\n * @experimental\n */\nvar CompilerFactory = /** @class */ (function () {\n    function CompilerFactory() {\n    }\n    return CompilerFactory;\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 * Represents an instance of a Component created via a {@link ComponentFactory}.\n *\n * `ComponentRef` provides access to the Component Instance as well other objects related to this\n * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}\n * method.\n *\n */\nvar ComponentRef = /** @class */ (function () {\n    function ComponentRef() {\n    }\n    return ComponentRef;\n}());\nvar ComponentFactory = /** @class */ (function () {\n    function ComponentFactory() {\n    }\n    return ComponentFactory;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction noComponentFactoryError(component) {\n    var error = Error(\"No component factory found for \" + stringify(component) + \". Did you add it to @NgModule.entryComponents?\");\n    error[ERROR_COMPONENT] = component;\n    return error;\n}\nvar ERROR_COMPONENT = 'ngComponent';\n\nvar _NullComponentFactoryResolver = /** @class */ (function () {\n    function _NullComponentFactoryResolver() {\n    }\n    _NullComponentFactoryResolver.prototype.resolveComponentFactory = function (component) {\n        throw noComponentFactoryError(component);\n    };\n    return _NullComponentFactoryResolver;\n}());\nvar ComponentFactoryResolver = /** @class */ (function () {\n    function ComponentFactoryResolver() {\n    }\n    ComponentFactoryResolver.NULL = new _NullComponentFactoryResolver();\n    return ComponentFactoryResolver;\n}());\nvar CodegenComponentFactoryResolver = /** @class */ (function () {\n    function CodegenComponentFactoryResolver(factories, _parent, _ngModule) {\n        this._parent = _parent;\n        this._ngModule = _ngModule;\n        this._factories = new Map();\n        for (var i = 0; i < factories.length; i++) {\n            var factory = factories[i];\n            this._factories.set(factory.componentType, factory);\n        }\n    }\n    CodegenComponentFactoryResolver.prototype.resolveComponentFactory = function (component) {\n        var 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    return CodegenComponentFactoryResolver;\n}());\nvar ComponentFactoryBoundToModule = /** @class */ (function (_super) {\n    __extends(ComponentFactoryBoundToModule, _super);\n    function ComponentFactoryBoundToModule(factory, ngModule) {\n        var _this = _super.call(this) || this;\n        _this.factory = factory;\n        _this.ngModule = ngModule;\n        _this.selector = factory.selector;\n        _this.componentType = factory.componentType;\n        _this.ngContentSelectors = factory.ngContentSelectors;\n        _this.inputs = factory.inputs;\n        _this.outputs = factory.outputs;\n        return _this;\n    }\n    ComponentFactoryBoundToModule.prototype.create = function (injector, projectableNodes, rootSelectorOrNode, ngModule) {\n        return this.factory.create(injector, projectableNodes, rootSelectorOrNode, ngModule || this.ngModule);\n    };\n    return ComponentFactoryBoundToModule;\n}(ComponentFactory));\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 * Represents an instance of an NgModule created via a {@link NgModuleFactory}.\n *\n * `NgModuleRef` provides access to the NgModule Instance as well other objects related to this\n * NgModule Instance.\n *\n *\n */\nvar NgModuleRef = /** @class */ (function () {\n    function NgModuleRef() {\n    }\n    return NgModuleRef;\n}());\n/**\n * @experimental\n */\nvar NgModuleFactory = /** @class */ (function () {\n    function NgModuleFactory() {\n    }\n    return NgModuleFactory;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar trace;\nvar events;\nfunction detectWTF() {\n    var wtf = _global /** 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}\nfunction createScope(signature, flags) {\n    if (flags === void 0) { flags = null; }\n    return events.createScope(signature, flags);\n}\nfunction leave(scope, returnValue) {\n    trace.leaveScope(scope, returnValue);\n    return returnValue;\n}\nfunction startTimeRange(rangeType, action) {\n    return trace.beginTimeRange(rangeType, action);\n}\nfunction endTimeRange(range) {\n    trace.endTimeRange(range);\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 * True if WTF is enabled.\n */\nvar wtfEnabled = detectWTF();\nfunction noopScope(arg0, arg1) {\n    return null;\n}\n/**\n * Create trace scope.\n *\n * Scopes must be strictly nested and are analogous to stack frames, but\n * do not have to follow the stack frames. Instead it is recommended that they follow logical\n * nesting. You may want to use\n * [Event\n * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)\n * as they are defined in WTF.\n *\n * Used to mark scope entry. The return value is used to leave the scope.\n *\n *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');\n *\n *     someMethod() {\n *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI\n *        // DO SOME WORK HERE\n *        return wtfLeave(s, 123); // Return value 123\n *     }\n *\n * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can\n * negatively impact the performance of your application. For this reason we recommend that\n * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and\n * so try-finally block has no value. When debugging perf issues, skipping `wtfLeave`, do to\n * exception, will produce incorrect trace, but presence of exception signifies logic error which\n * needs to be fixed before the app should be profiled. Add try-finally only when you expect that\n * an exception is expected during normal execution while profiling.\n *\n * @experimental\n */\nvar wtfCreateScope = wtfEnabled ? createScope : function (signature, flags) { return noopScope; };\n/**\n * Used to mark end of Scope.\n *\n * - `scope` to end.\n * - `returnValue` (optional) to be passed to the WTF.\n *\n * Returns the `returnValue for easy chaining.\n * @experimental\n */\nvar wtfLeave = wtfEnabled ? leave : function (s, r) { return r; };\n/**\n * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.\n * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been\n * enabled.\n *\n *     someMethod() {\n *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');\n *        var future = new Future.delay(5).then((_) {\n *          wtfEndTimeRange(s);\n *        });\n *     }\n * @experimental\n */\nvar wtfStartTimeRange = wtfEnabled ? startTimeRange : function (rangeType, action) { return null; };\n/**\n * Ends a async time range operation.\n * [range] is the return value from [wtfStartTimeRange] Async ranges only work if WTF has been\n * enabled.\n * @experimental\n */\nvar wtfEndTimeRange = wtfEnabled ? endTimeRange : function (r) { return 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 * Use by directives and components to emit custom Events.\n *\n * @usageNotes\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 * ### Notes\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 *\n */\nvar EventEmitter = /** @class */ (function (_super) {\n    __extends(EventEmitter, _super);\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     */\n    function EventEmitter(isAsync) {\n        if (isAsync === void 0) { isAsync = false; }\n        var _this = _super.call(this) || this;\n        _this.__isAsync = isAsync;\n        return _this;\n    }\n    EventEmitter.prototype.emit = function (value) { _super.prototype.next.call(this, value); };\n    EventEmitter.prototype.subscribe = function (generatorOrNext, error, complete) {\n        var schedulerFn;\n        var errorFn = function (err) { return null; };\n        var completeFn = function () { return null; };\n        if (generatorOrNext && typeof generatorOrNext === 'object') {\n            schedulerFn = this.__isAsync ? function (value) {\n                setTimeout(function () { return generatorOrNext.next(value); });\n            } : function (value) { generatorOrNext.next(value); };\n            if (generatorOrNext.error) {\n                errorFn = this.__isAsync ? function (err) { setTimeout(function () { return generatorOrNext.error(err); }); } :\n                    function (err) { generatorOrNext.error(err); };\n            }\n            if (generatorOrNext.complete) {\n                completeFn = this.__isAsync ? function () { setTimeout(function () { return generatorOrNext.complete(); }); } :\n                    function () { generatorOrNext.complete(); };\n            }\n        }\n        else {\n            schedulerFn = this.__isAsync ? function (value) { setTimeout(function () { return generatorOrNext(value); }); } :\n                function (value) { generatorOrNext(value); };\n            if (error) {\n                errorFn =\n                    this.__isAsync ? function (err) { setTimeout(function () { return error(err); }); } : function (err) { error(err); };\n            }\n            if (complete) {\n                completeFn =\n                    this.__isAsync ? function () { setTimeout(function () { return complete(); }); } : function () { complete(); };\n            }\n        }\n        var sink = _super.prototype.subscribe.call(this, schedulerFn, errorFn, completeFn);\n        if (generatorOrNext instanceof rxjs.Subscription) {\n            generatorOrNext.add(sink);\n        }\n        return sink;\n    };\n    return EventEmitter;\n}(rxjs.Subject));\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 * 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 * @usageNotes\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 *\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 */\nvar NgZone = /** @class */ (function () {\n    function NgZone(_a) {\n        var _b = _a.enableLongStackTrace, enableLongStackTrace = _b === void 0 ? false : _b;\n        this.hasPendingMicrotasks = false;\n        this.hasPendingMacrotasks = false;\n        /**\n         * Whether there are no outstanding microtasks or macrotasks.\n         */\n        this.isStable = true;\n        /**\n         * Notifies when code enters Angular Zone. This gets fired first on VM Turn.\n         */\n        this.onUnstable = new EventEmitter(false);\n        /**\n         * Notifies when there is no more microtasks enqueued 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         */\n        this.onMicrotaskEmpty = new EventEmitter(false);\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         */\n        this.onStable = new EventEmitter(false);\n        /**\n         * Notifies that an error has been delivered.\n         */\n        this.onError = new EventEmitter(false);\n        if (typeof Zone == 'undefined') {\n            throw new Error(\"In this configuration Angular requires Zone.js\");\n        }\n        Zone.assertZonePatched();\n        var self = this;\n        self._nesting = 0;\n        self._outer = self._inner = Zone.current;\n        if (Zone['wtfZoneSpec']) {\n            self._inner = self._inner.fork(Zone['wtfZoneSpec']);\n        }\n        if (Zone['TaskTrackingZoneSpec']) {\n            self._inner = self._inner.fork(new Zone['TaskTrackingZoneSpec']);\n        }\n        if (enableLongStackTrace && Zone['longStackTraceZoneSpec']) {\n            self._inner = self._inner.fork(Zone['longStackTraceZoneSpec']);\n        }\n        forkInnerZoneWithAngularBehavior(self);\n    }\n    NgZone.isInAngularZone = function () { return Zone.current.get('isAngularZone') === true; };\n    NgZone.assertInAngularZone = function () {\n        if (!NgZone.isInAngularZone()) {\n            throw new Error('Expected to be in Angular Zone, but it is not!');\n        }\n    };\n    NgZone.assertNotInAngularZone = function () {\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     */\n    NgZone.prototype.run = function (fn, applyThis, applyArgs) {\n        return this._inner.run(fn, applyThis, applyArgs);\n    };\n    /**\n     * Executes the `fn` function synchronously within the Angular zone as a task and returns value\n     * returned by 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     */\n    NgZone.prototype.runTask = function (fn, applyThis, applyArgs, name) {\n        var zone = this._inner;\n        var task = zone.scheduleEventTask('NgZoneEvent: ' + name, fn, EMPTY_PAYLOAD, noop, noop);\n        try {\n            return zone.runTask(task, applyThis, applyArgs);\n        }\n        finally {\n            zone.cancelTask(task);\n        }\n    };\n    /**\n     * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not\n     * rethrown.\n     */\n    NgZone.prototype.runGuarded = function (fn, applyThis, applyArgs) {\n        return this._inner.runGuarded(fn, applyThis, applyArgs);\n    };\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     */\n    NgZone.prototype.runOutsideAngular = function (fn) {\n        return this._outer.run(fn);\n    };\n    return NgZone;\n}());\nfunction noop() { }\nvar EMPTY_PAYLOAD = {};\nfunction checkStable(zone) {\n    if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {\n        try {\n            zone._nesting++;\n            zone.onMicrotaskEmpty.emit(null);\n        }\n        finally {\n            zone._nesting--;\n            if (!zone.hasPendingMicrotasks) {\n                try {\n                    zone.runOutsideAngular(function () { return zone.onStable.emit(null); });\n                }\n                finally {\n                    zone.isStable = true;\n                }\n            }\n        }\n    }\n}\nfunction forkInnerZoneWithAngularBehavior(zone) {\n    zone._inner = zone._inner.fork({\n        name: 'angular',\n        properties: { 'isAngularZone': true },\n        onInvokeTask: function (delegate, current, target, task, applyThis, applyArgs) {\n            try {\n                onEnter(zone);\n                return delegate.invokeTask(target, task, applyThis, applyArgs);\n            }\n            finally {\n                onLeave(zone);\n            }\n        },\n        onInvoke: function (delegate, current, target, callback, applyThis, applyArgs, source) {\n            try {\n                onEnter(zone);\n                return delegate.invoke(target, callback, applyThis, applyArgs, source);\n            }\n            finally {\n                onLeave(zone);\n            }\n        },\n        onHasTask: function (delegate, current, target, 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                    zone.hasPendingMicrotasks = hasTaskState.microTask;\n                    checkStable(zone);\n                }\n                else if (hasTaskState.change == 'macroTask') {\n                    zone.hasPendingMacrotasks = hasTaskState.macroTask;\n                }\n            }\n        },\n        onHandleError: function (delegate, current, target, error) {\n            delegate.handleError(target, error);\n            zone.runOutsideAngular(function () { return zone.onError.emit(error); });\n            return false;\n        }\n    });\n}\nfunction onEnter(zone) {\n    zone._nesting++;\n    if (zone.isStable) {\n        zone.isStable = false;\n        zone.onUnstable.emit(null);\n    }\n}\nfunction onLeave(zone) {\n    zone._nesting--;\n    checkStable(zone);\n}\n/**\n * Provides a noop implementation of `NgZone` which does nothing. This zone requires explicit calls\n * to framework to perform rendering.\n */\nvar NoopNgZone = /** @class */ (function () {\n    function NoopNgZone() {\n        this.hasPendingMicrotasks = false;\n        this.hasPendingMacrotasks = false;\n        this.isStable = true;\n        this.onUnstable = new EventEmitter();\n        this.onMicrotaskEmpty = new EventEmitter();\n        this.onStable = new EventEmitter();\n        this.onError = new EventEmitter();\n    }\n    NoopNgZone.prototype.run = function (fn) { return fn(); };\n    NoopNgZone.prototype.runGuarded = function (fn) { return fn(); };\n    NoopNgZone.prototype.runOutsideAngular = function (fn) { return fn(); };\n    NoopNgZone.prototype.runTask = function (fn) { return fn(); };\n    return NoopNgZone;\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 * 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 */\nvar Testability = /** @class */ (function () {\n    function Testability(_ngZone) {\n        var _this = this;\n        this._ngZone = _ngZone;\n        this._pendingCount = 0;\n        this._isZoneStable = 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        this._didWork = false;\n        this._callbacks = [];\n        this._watchAngularEvents();\n        _ngZone.run(function () { _this.taskTrackingZone = Zone.current.get('TaskTrackingZone'); });\n    }\n    Testability.prototype._watchAngularEvents = function () {\n        var _this = this;\n        this._ngZone.onUnstable.subscribe({\n            next: function () {\n                _this._didWork = true;\n                _this._isZoneStable = false;\n            }\n        });\n        this._ngZone.runOutsideAngular(function () {\n            _this._ngZone.onStable.subscribe({\n                next: function () {\n                    NgZone.assertNotInAngularZone();\n                    scheduleMicroTask(function () {\n                        _this._isZoneStable = true;\n                        _this._runCallbacksIfReady();\n                    });\n                }\n            });\n        });\n    };\n    /**\n     * Increases the number of pending request\n     * @deprecated pending requests are now tracked with zones.\n     */\n    Testability.prototype.increasePendingRequestCount = function () {\n        this._pendingCount += 1;\n        this._didWork = true;\n        return this._pendingCount;\n    };\n    /**\n     * Decreases the number of pending request\n     * @deprecated pending requests are now tracked with zones\n     */\n    Testability.prototype.decreasePendingRequestCount = function () {\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     * Whether an associated application is stable\n     */\n    Testability.prototype.isStable = function () {\n        return this._isZoneStable && this._pendingCount === 0 && !this._ngZone.hasPendingMacrotasks;\n    };\n    Testability.prototype._runCallbacksIfReady = function () {\n        var _this = this;\n        if (this.isStable()) {\n            // Schedules the call backs in a new frame so that it is always async.\n            scheduleMicroTask(function () {\n                while (_this._callbacks.length !== 0) {\n                    var cb = _this._callbacks.pop();\n                    clearTimeout(cb.timeoutId);\n                    cb.doneCb(_this._didWork);\n                }\n                _this._didWork = false;\n            });\n        }\n        else {\n            // Still not stable, send updates.\n            var pending_1 = this.getPendingTasks();\n            this._callbacks = this._callbacks.filter(function (cb) {\n                if (cb.updateCb && cb.updateCb(pending_1)) {\n                    clearTimeout(cb.timeoutId);\n                    return false;\n                }\n                return true;\n            });\n            this._didWork = true;\n        }\n    };\n    Testability.prototype.getPendingTasks = function () {\n        if (!this.taskTrackingZone) {\n            return [];\n        }\n        return this.taskTrackingZone.macroTasks.map(function (t) {\n            return {\n                source: t.source,\n                isPeriodic: t.data.isPeriodic,\n                delay: t.data.delay,\n                // From TaskTrackingZone:\n                // https://github.com/angular/zone.js/blob/master/lib/zone-spec/task-tracking.ts#L40\n                creationLocation: t.creationLocation,\n                // Added by Zones for XHRs\n                // https://github.com/angular/zone.js/blob/master/lib/browser/browser.ts#L133\n                xhr: t.data.target\n            };\n        });\n    };\n    Testability.prototype.addCallback = function (cb, timeout, updateCb) {\n        var _this = this;\n        var timeoutId = -1;\n        if (timeout && timeout > 0) {\n            timeoutId = setTimeout(function () {\n                _this._callbacks = _this._callbacks.filter(function (cb) { return cb.timeoutId !== timeoutId; });\n                cb(_this._didWork, _this.getPendingTasks());\n            }, timeout);\n        }\n        this._callbacks.push({ doneCb: cb, timeoutId: timeoutId, updateCb: updateCb });\n    };\n    /**\n     * Wait for the application to be stable with a timeout. If the timeout is reached before that\n     * happens, the callback receives a list of the macro tasks that were pending, otherwise null.\n     *\n     * @param doneCb The callback to invoke when Angular is stable or the timeout expires\n     *    whichever comes first.\n     * @param timeout Optional. The maximum time to wait for Angular to become stable. If not\n     *    specified, whenStable() will wait forever.\n     * @param updateCb Optional. If specified, this callback will be invoked whenever the set of\n     *    pending macrotasks changes. If this callback returns true doneCb will not be invoked\n     *    and no further updates will be issued.\n     */\n    Testability.prototype.whenStable = function (doneCb, timeout, updateCb) {\n        if (updateCb && !this.taskTrackingZone) {\n            throw new Error('Task tracking zone is required when passing an update callback to ' +\n                'whenStable(). Is \"zone.js/dist/task-tracking.js\" loaded?');\n        }\n        // These arguments are 'Function' above to keep the public API simple.\n        this.addCallback(doneCb, timeout, updateCb);\n        this._runCallbacksIfReady();\n    };\n    /**\n     * Get the number of pending requests\n     * @deprecated pending requests are now tracked with zones\n     */\n    Testability.prototype.getPendingRequestCount = function () { return this._pendingCount; };\n    /**\n     * Find providers by name\n     * @param using The root element to search from\n     * @param provider The name of binding variable\n     * @param exactMatch Whether using exactMatch\n     */\n    Testability.prototype.findProviders = function (using, provider, exactMatch) {\n        // TODO(juliemr): implement.\n        return [];\n    };\n    Testability.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    Testability.ctorParameters = function () { return [\n        { type: NgZone }\n    ]; };\n    return Testability;\n}());\n/**\n * A global registry of {@link Testability} instances for specific elements.\n * @experimental\n */\nvar TestabilityRegistry = /** @class */ (function () {\n    function TestabilityRegistry() {\n        /** @internal */\n        this._applications = new Map();\n        _testabilityGetter.addToWindow(this);\n    }\n    /**\n     * Registers an application with a testability hook so that it can be tracked\n     * @param token token of application, root element\n     * @param testability Testability hook\n     */\n    TestabilityRegistry.prototype.registerApplication = function (token, testability) {\n        this._applications.set(token, testability);\n    };\n    /**\n     * Unregisters an application.\n     * @param token token of application, root element\n     */\n    TestabilityRegistry.prototype.unregisterApplication = function (token) { this._applications.delete(token); };\n    /**\n     * Unregisters all applications\n     */\n    TestabilityRegistry.prototype.unregisterAllApplications = function () { this._applications.clear(); };\n    /**\n     * Get a testability hook associated with the application\n     * @param elem root element\n     */\n    TestabilityRegistry.prototype.getTestability = function (elem) { return this._applications.get(elem) || null; };\n    /**\n     * Get all registered testabilities\n     */\n    TestabilityRegistry.prototype.getAllTestabilities = function () { return Array.from(this._applications.values()); };\n    /**\n     * Get all registered applications(root elements)\n     */\n    TestabilityRegistry.prototype.getAllRootElements = function () { return Array.from(this._applications.keys()); };\n    /**\n     * Find testability of a node in the Tree\n     * @param elem node\n     * @param findInAncestors whether finding testability in ancestors if testability was not found in\n     * current node\n     */\n    TestabilityRegistry.prototype.findTestabilityInTree = function (elem, findInAncestors) {\n        if (findInAncestors === void 0) { findInAncestors = true; }\n        return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);\n    };\n    TestabilityRegistry.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    TestabilityRegistry.ctorParameters = function () { return []; };\n    return TestabilityRegistry;\n}());\nvar _NoopGetTestability = /** @class */ (function () {\n    function _NoopGetTestability() {\n    }\n    _NoopGetTestability.prototype.addToWindow = function (registry) { };\n    _NoopGetTestability.prototype.findTestabilityInTree = function (registry, elem, findInAncestors) {\n        return null;\n    };\n    return _NoopGetTestability;\n}());\n/**\n * Set the {@link GetTestability} implementation used by the Angular testing framework.\n * @experimental\n */\nfunction setTestabilityGetter(getter) {\n    _testabilityGetter = getter;\n}\nvar _testabilityGetter = new _NoopGetTestability();\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _devMode = true;\nvar _runModeLocked = false;\nvar _platform;\nvar ALLOW_MULTIPLE_PLATFORMS = new InjectionToken('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 *\n */\nfunction enableProdMode() {\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 */\nfunction isDevMode() {\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 */\nvar NgProbeToken = /** @class */ (function () {\n    function NgProbeToken(name, token) {\n        this.name = name;\n        this.token = token;\n    }\n    return NgProbeToken;\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 */\nfunction createPlatform(injector) {\n    if (_platform && !_platform.destroyed &&\n        !_platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n        throw new Error('There can be only one platform. Destroy the previous one to create a new one.');\n    }\n    _platform = injector.get(PlatformRef);\n    var inits = injector.get(PLATFORM_INITIALIZER, null);\n    if (inits)\n        inits.forEach(function (init) { return 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 */\nfunction createPlatformFactory(parentPlatformFactory, name, providers) {\n    if (providers === void 0) { providers = []; }\n    var desc = \"Platform: \" + name;\n    var marker = new InjectionToken(desc);\n    return function (extraProviders) {\n        if (extraProviders === void 0) { extraProviders = []; }\n        var platform = getPlatform();\n        if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n            if (parentPlatformFactory) {\n                parentPlatformFactory(providers.concat(extraProviders).concat({ provide: marker, useValue: true }));\n            }\n            else {\n                var injectedProviders = providers.concat(extraProviders).concat({ provide: marker, useValue: true });\n                createPlatform(Injector.create({ providers: injectedProviders, name: desc }));\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 */\nfunction assertPlatform(requiredToken) {\n    var platform = getPlatform();\n    if (!platform) {\n        throw new Error('No platform exists!');\n    }\n    if (!platform.injector.get(requiredToken, null)) {\n        throw new Error('A platform with a different configuration has been created. Please destroy it first.');\n    }\n    return platform;\n}\n/**\n * Destroy the existing platform.\n *\n * @experimental APIs related to application bootstrap are currently under review.\n */\nfunction destroyPlatform() {\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 */\nfunction getPlatform() {\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 */\nvar PlatformRef = /** @class */ (function () {\n    /** @internal */\n    function PlatformRef(_injector) {\n        this._injector = _injector;\n        this._modules = [];\n        this._destroyListeners = [];\n        this._destroyed = false;\n    }\n    /**\n     * Creates an instance of an `@NgModule` for the given platform\n     * for offline compilation.\n     *\n     * @usageNotes\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     */\n    PlatformRef.prototype.bootstrapModuleFactory = function (moduleFactory, options) {\n        var _this = this;\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        var ngZoneOption = options ? options.ngZone : undefined;\n        var ngZone = getNgZone(ngZoneOption);\n        var providers = [{ provide: NgZone, useValue: ngZone }];\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(function () {\n            var ngZoneInjector = Injector.create({ providers: providers, parent: _this.injector, name: moduleFactory.moduleType.name });\n            var moduleRef = moduleFactory.create(ngZoneInjector);\n            var exceptionHandler = moduleRef.injector.get(ErrorHandler, null);\n            if (!exceptionHandler) {\n                throw new Error('No ErrorHandler. Is platform module (BrowserModule) included?');\n            }\n            moduleRef.onDestroy(function () { return remove(_this._modules, moduleRef); });\n            ngZone.runOutsideAngular(function () { return ngZone.onError.subscribe({ next: function (error) { exceptionHandler.handleError(error); } }); });\n            return _callAndReportToErrorHandler(exceptionHandler, ngZone, function () {\n                var initStatus = moduleRef.injector.get(ApplicationInitStatus);\n                initStatus.runInitializers();\n                return initStatus.donePromise.then(function () {\n                    _this._moduleDoBootstrap(moduleRef);\n                    return moduleRef;\n                });\n            });\n        });\n    };\n    /**\n     * Creates an instance of an `@NgModule` for a given platform using the given runtime compiler.\n     *\n     * @usageNotes\n     * ### Simple Example\n     *\n     * ```typescript\n     * @NgModule({\n     *   imports: [BrowserModule]\n     * })\n     * class MyModule {}\n     *\n     * let moduleRef = platformBrowser().bootstrapModule(MyModule);\n     * ```\n     *\n     */\n    PlatformRef.prototype.bootstrapModule = function (moduleType, compilerOptions) {\n        var _this = this;\n        if (compilerOptions === void 0) { compilerOptions = []; }\n        var compilerFactory = this.injector.get(CompilerFactory);\n        var options = optionsReducer({}, compilerOptions);\n        var compiler = compilerFactory.createCompiler([options]);\n        return compiler.compileModuleAsync(moduleType)\n            .then(function (moduleFactory) { return _this.bootstrapModuleFactory(moduleFactory, options); });\n    };\n    PlatformRef.prototype._moduleDoBootstrap = function (moduleRef) {\n        var appRef = moduleRef.injector.get(ApplicationRef);\n        if (moduleRef._bootstrapComponents.length > 0) {\n            moduleRef._bootstrapComponents.forEach(function (f) { return appRef.bootstrap(f); });\n        }\n        else if (moduleRef.instance.ngDoBootstrap) {\n            moduleRef.instance.ngDoBootstrap(appRef);\n        }\n        else {\n            throw new Error(\"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    };\n    /**\n     * Register a listener to be called when the platform is disposed.\n     */\n    PlatformRef.prototype.onDestroy = function (callback) { this._destroyListeners.push(callback); };\n    Object.defineProperty(PlatformRef.prototype, \"injector\", {\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         */\n        get: function () { return this._injector; },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Destroy the Angular platform and all Angular applications on the page.\n     */\n    PlatformRef.prototype.destroy = function () {\n        if (this._destroyed) {\n            throw new Error('The platform has already been destroyed!');\n        }\n        this._modules.slice().forEach(function (module) { return module.destroy(); });\n        this._destroyListeners.forEach(function (listener) { return listener(); });\n        this._destroyed = true;\n    };\n    Object.defineProperty(PlatformRef.prototype, \"destroyed\", {\n        get: function () { return this._destroyed; },\n        enumerable: true,\n        configurable: true\n    });\n    PlatformRef.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    PlatformRef.ctorParameters = function () { return [\n        { type: Injector }\n    ]; };\n    return PlatformRef;\n}());\nfunction getNgZone(ngZoneOption) {\n    var ngZone;\n    if (ngZoneOption === 'noop') {\n        ngZone = new NoopNgZone();\n    }\n    else {\n        ngZone = (ngZoneOption === 'zone.js' ? undefined : ngZoneOption) ||\n            new NgZone({ enableLongStackTrace: isDevMode() });\n    }\n    return ngZone;\n}\nfunction _callAndReportToErrorHandler(errorHandler, ngZone, callback) {\n    try {\n        var result = callback();\n        if (isPromise(result)) {\n            return result.catch(function (e) {\n                ngZone.runOutsideAngular(function () { return errorHandler.handleError(e); });\n                // rethrow as the exception handler might not do it\n                throw e;\n            });\n        }\n        return result;\n    }\n    catch (e) {\n        ngZone.runOutsideAngular(function () { return errorHandler.handleError(e); });\n        // rethrow as the exception handler might not do it\n        throw e;\n    }\n}\nfunction optionsReducer(dst, objs) {\n    if (Array.isArray(objs)) {\n        dst = objs.reduce(optionsReducer, dst);\n    }\n    else {\n        dst = __assign({}, dst, objs);\n    }\n    return dst;\n}\n/**\n * A reference to an Angular application running on a page.\n */\nvar ApplicationRef = /** @class */ (function () {\n    /** @internal */\n    function ApplicationRef(_zone, _console, _injector, _exceptionHandler, _componentFactoryResolver, _initStatus) {\n        var _this = this;\n        this._zone = _zone;\n        this._console = _console;\n        this._injector = _injector;\n        this._exceptionHandler = _exceptionHandler;\n        this._componentFactoryResolver = _componentFactoryResolver;\n        this._initStatus = _initStatus;\n        this._bootstrapListeners = [];\n        this._views = [];\n        this._runningTick = false;\n        this._enforceNoNewChanges = false;\n        this._stable = true;\n        /**\n         * Get a list of component types registered to this application.\n         * This list is populated even before the component is created.\n         */\n        this.componentTypes = [];\n        /**\n         * Get a list of components registered to this application.\n         */\n        this.components = [];\n        this._enforceNoNewChanges = isDevMode();\n        this._zone.onMicrotaskEmpty.subscribe({ next: function () { _this._zone.run(function () { _this.tick(); }); } });\n        var isCurrentlyStable = new rxjs.Observable(function (observer) {\n            _this._stable = _this._zone.isStable && !_this._zone.hasPendingMacrotasks &&\n                !_this._zone.hasPendingMicrotasks;\n            _this._zone.runOutsideAngular(function () {\n                observer.next(_this._stable);\n                observer.complete();\n            });\n        });\n        var isStable = new rxjs.Observable(function (observer) {\n            // Create the subscription to onStable outside the Angular Zone so that\n            // the callback is run outside the Angular Zone.\n            var stableSub;\n            _this._zone.runOutsideAngular(function () {\n                stableSub = _this._zone.onStable.subscribe(function () {\n                    NgZone.assertNotInAngularZone();\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(function () {\n                        if (!_this._stable && !_this._zone.hasPendingMacrotasks &&\n                            !_this._zone.hasPendingMicrotasks) {\n                            _this._stable = true;\n                            observer.next(true);\n                        }\n                    });\n                });\n            });\n            var unstableSub = _this._zone.onUnstable.subscribe(function () {\n                NgZone.assertInAngularZone();\n                if (_this._stable) {\n                    _this._stable = false;\n                    _this._zone.runOutsideAngular(function () { observer.next(false); });\n                }\n            });\n            return function () {\n                stableSub.unsubscribe();\n                unstableSub.unsubscribe();\n            };\n        });\n        this.isStable =\n            rxjs.merge(isCurrentlyStable, isStable.pipe(operators.share()));\n    }\n    /**\n     * Bootstrap a new component at the root level of the application.\n     *\n     * @usageNotes\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     */\n    ApplicationRef.prototype.bootstrap = function (componentOrFactory, rootSelectorOrNode) {\n        var _this = this;\n        if (!this._initStatus.done) {\n            throw new Error('Cannot bootstrap as there are still asynchronous initializers running. Bootstrap components in the `ngDoBootstrap` method of the root module.');\n        }\n        var componentFactory;\n        if (componentOrFactory instanceof ComponentFactory) {\n            componentFactory = componentOrFactory;\n        }\n        else {\n            componentFactory =\n                this._componentFactoryResolver.resolveComponentFactory(componentOrFactory);\n        }\n        this.componentTypes.push(componentFactory.componentType);\n        // Create a factory associated with the current module if it's not bound to some other\n        var ngModule = componentFactory instanceof ComponentFactoryBoundToModule ?\n            null :\n            this._injector.get(NgModuleRef);\n        var selectorOrNode = rootSelectorOrNode || componentFactory.selector;\n        var compRef = componentFactory.create(Injector.NULL, [], selectorOrNode, ngModule);\n        compRef.onDestroy(function () { _this._unloadComponent(compRef); });\n        var testability = compRef.injector.get(Testability, null);\n        if (testability) {\n            compRef.injector.get(TestabilityRegistry)\n                .registerApplication(compRef.location.nativeElement, testability);\n        }\n        this._loadComponent(compRef);\n        if (isDevMode()) {\n            this._console.log(\"Angular is running in the development mode. Call enableProdMode() to enable the production mode.\");\n        }\n        return compRef;\n    };\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     */\n    ApplicationRef.prototype.tick = function () {\n        var _this = this;\n        if (this._runningTick) {\n            throw new Error('ApplicationRef.tick is called recursively');\n        }\n        var scope = ApplicationRef._tickScope();\n        try {\n            this._runningTick = true;\n            this._views.forEach(function (view) { return view.detectChanges(); });\n            if (this._enforceNoNewChanges) {\n                this._views.forEach(function (view) { return view.checkNoChanges(); });\n            }\n        }\n        catch (e) {\n            // Attention: Don't rethrow as it could cancel subscriptions to Observables!\n            this._zone.runOutsideAngular(function () { return _this._exceptionHandler.handleError(e); });\n        }\n        finally {\n            this._runningTick = false;\n            wtfLeave(scope);\n        }\n    };\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     */\n    ApplicationRef.prototype.attachView = function (viewRef) {\n        var view = viewRef;\n        this._views.push(view);\n        view.attachToAppRef(this);\n    };\n    /**\n     * Detaches a view from dirty checking again.\n     */\n    ApplicationRef.prototype.detachView = function (viewRef) {\n        var view = viewRef;\n        remove(this._views, view);\n        view.detachFromAppRef();\n    };\n    ApplicationRef.prototype._loadComponent = function (componentRef) {\n        this.attachView(componentRef.hostView);\n        this.tick();\n        this.components.push(componentRef);\n        // Get the listeners lazily to prevent DI cycles.\n        var listeners = this._injector.get(APP_BOOTSTRAP_LISTENER, []).concat(this._bootstrapListeners);\n        listeners.forEach(function (listener) { return listener(componentRef); });\n    };\n    ApplicationRef.prototype._unloadComponent = function (componentRef) {\n        this.detachView(componentRef.hostView);\n        remove(this.components, componentRef);\n    };\n    /** @internal */\n    ApplicationRef.prototype.ngOnDestroy = function () {\n        // TODO(alxhub): Dispose of the NgZone.\n        this._views.slice().forEach(function (view) { return view.destroy(); });\n    };\n    Object.defineProperty(ApplicationRef.prototype, \"viewCount\", {\n        /**\n         * Returns the number of attached views.\n         */\n        get: function () { return this._views.length; },\n        enumerable: true,\n        configurable: true\n    });\n    /** @internal */\n    ApplicationRef._tickScope = wtfCreateScope('ApplicationRef#tick()');\n    ApplicationRef.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    ApplicationRef.ctorParameters = function () { return [\n        { type: NgZone },\n        { type: Console },\n        { type: Injector },\n        { type: ErrorHandler },\n        { type: ComponentFactoryResolver },\n        { type: ApplicationInitStatus }\n    ]; };\n    return ApplicationRef;\n}());\nfunction remove(list, el) {\n    var index = list.indexOf(el);\n    if (index > -1) {\n        list.splice(index, 1);\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// Public API for Zone\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 * @deprecated Use `RendererType2` (and `Renderer2`) instead.\n */\nvar RenderComponentType = /** @class */ (function () {\n    function RenderComponentType(id, templateUrl, slotCount, encapsulation, styles, animations) {\n        this.id = id;\n        this.templateUrl = templateUrl;\n        this.slotCount = slotCount;\n        this.encapsulation = encapsulation;\n        this.styles = styles;\n        this.animations = animations;\n    }\n    return RenderComponentType;\n}());\n/**\n * @deprecated Debug info is handeled internally in the view engine now.\n */\nvar RenderDebugInfo = /** @class */ (function () {\n    function RenderDebugInfo() {\n    }\n    return RenderDebugInfo;\n}());\n/**\n * @deprecated Use the `Renderer2` instead.\n */\nvar Renderer = /** @class */ (function () {\n    function Renderer() {\n    }\n    return Renderer;\n}());\nvar Renderer2Interceptor = new InjectionToken('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 setElementProperty} or\n * {@link Renderer#setElementAttribute setElementAttribute} 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 */\nvar RootRenderer = /** @class */ (function () {\n    function RootRenderer() {\n    }\n    return RootRenderer;\n}());\n/**\n * @experimental\n */\nvar RendererFactory2 = /** @class */ (function () {\n    function RendererFactory2() {\n    }\n    return RendererFactory2;\n}());\n/**\n * @experimental\n */\n\n(function (RendererStyleFlags2) {\n    RendererStyleFlags2[RendererStyleFlags2[\"Important\"] = 1] = \"Important\";\n    RendererStyleFlags2[RendererStyleFlags2[\"DashCase\"] = 2] = \"DashCase\";\n})(exports.RendererStyleFlags2 || (exports.RendererStyleFlags2 = {}));\n/**\n * @experimental\n */\nvar Renderer2 = /** @class */ (function () {\n    function Renderer2() {\n    }\n    return Renderer2;\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// Public API for render\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A wrapper around a native element inside of a View.\n *\n * An `ElementRef` is backed by a render-specific element. In the browser, this is usually a DOM\n * element.\n *\n * @security Permitting direct access to the DOM can make your application more vulnerable to\n * XSS attacks. Carefully review any use of `ElementRef` in your code. For more detail, see the\n * [Security Guide](http://g.co/ng/security).\n *\n *\n */\n// Note: We don't expose things like `Injector`, `ViewContainer`, ... here,\n// i.e. users have to ask for what they need. With that, we can build better analysis tools\n// and could do better codegen in the future.\nvar ElementRef = /** @class */ (function () {\n    function ElementRef(nativeElement) {\n        this.nativeElement = nativeElement;\n    }\n    return ElementRef;\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 * Used to load ng module factories.\n *\n */\nvar NgModuleFactoryLoader = /** @class */ (function () {\n    function NgModuleFactoryLoader() {\n    }\n    return NgModuleFactoryLoader;\n}());\nvar moduleFactories = new Map();\n/**\n * Registers a loaded module. Should only be called from generated NgModuleFactory code.\n * @experimental\n */\nfunction registerModuleFactory(id, factory) {\n    var existing = moduleFactories.get(id);\n    if (existing) {\n        throw new Error(\"Duplicate module registered for \" + id + \" - \" + existing.moduleType.name + \" vs \" + factory.moduleType.name);\n    }\n    moduleFactories.set(id, factory);\n}\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 */\nfunction getModuleFactory(id) {\n    var factory = moduleFactories.get(id);\n    if (!factory)\n        throw new Error(\"No module with ID \" + id + \" loaded\");\n    return factory;\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 * 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 * @usageNotes\n * ### Example\n * ```typescript\n * @Component({...})\n * class Container {\n *   @ViewChildren(Item) items:QueryList<Item>;\n * }\n * ```\n */\nvar QueryList = /** @class */ (function () {\n    function QueryList() {\n        this.dirty = true;\n        this._results = [];\n        this.changes = new EventEmitter();\n        this.length = 0;\n    }\n    /**\n     * See\n     * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n     */\n    QueryList.prototype.map = function (fn) { 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     */\n    QueryList.prototype.filter = function (fn) {\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     */\n    QueryList.prototype.find = function (fn) {\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     */\n    QueryList.prototype.reduce = function (fn, init) {\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     */\n    QueryList.prototype.forEach = function (fn) { 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     */\n    QueryList.prototype.some = function (fn) {\n        return this._results.some(fn);\n    };\n    QueryList.prototype.toArray = function () { return this._results.slice(); };\n    QueryList.prototype[getSymbolIterator()] = function () { return this._results[getSymbolIterator()](); };\n    QueryList.prototype.toString = function () { return this._results.toString(); };\n    QueryList.prototype.reset = function (res) {\n        this._results = flatten(res);\n        this.dirty = false;\n        this.length = this._results.length;\n        this.last = this._results[this.length - 1];\n        this.first = this._results[0];\n    };\n    QueryList.prototype.notifyOnChanges = function () { this.changes.emit(this); };\n    /** internal */\n    QueryList.prototype.setDirty = function () { this.dirty = true; };\n    /** internal */\n    QueryList.prototype.destroy = function () {\n        this.changes.complete();\n        this.changes.unsubscribe();\n    };\n    return QueryList;\n}());\nfunction flatten(list) {\n    return list.reduce(function (flat, item) {\n        var flatItem = Array.isArray(item) ? flatten(item) : item;\n        return flat.concat(flatItem);\n    }, []);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _SEPARATOR = '#';\nvar FACTORY_CLASS_SUFFIX = 'NgFactory';\n/**\n * Configuration for SystemJsNgModuleLoader.\n * token.\n *\n * @experimental\n */\nvar SystemJsNgModuleLoaderConfig = /** @class */ (function () {\n    function SystemJsNgModuleLoaderConfig() {\n    }\n    return SystemJsNgModuleLoaderConfig;\n}());\nvar DEFAULT_CONFIG = {\n    factoryPathPrefix: '',\n    factoryPathSuffix: '.ngfactory',\n};\n/**\n * NgModuleFactoryLoader that uses SystemJS to load NgModuleFactory\n * @experimental\n */\nvar SystemJsNgModuleLoader = /** @class */ (function () {\n    function SystemJsNgModuleLoader(_compiler, config) {\n        this._compiler = _compiler;\n        this._config = config || DEFAULT_CONFIG;\n    }\n    SystemJsNgModuleLoader.prototype.load = function (path) {\n        var offlineMode = this._compiler instanceof Compiler;\n        return offlineMode ? this.loadFactory(path) : this.loadAndCompile(path);\n    };\n    SystemJsNgModuleLoader.prototype.loadAndCompile = function (path) {\n        var _this = this;\n        var _a = __read(path.split(_SEPARATOR), 2), module = _a[0], exportName = _a[1];\n        if (exportName === undefined) {\n            exportName = 'default';\n        }\n        return System.import(module)\n            .then(function (module) { return module[exportName]; })\n            .then(function (type) { return checkNotEmpty(type, module, exportName); })\n            .then(function (type) { return _this._compiler.compileModuleAsync(type); });\n    };\n    SystemJsNgModuleLoader.prototype.loadFactory = function (path) {\n        var _a = __read(path.split(_SEPARATOR), 2), module = _a[0], exportName = _a[1];\n        var factoryClassSuffix = FACTORY_CLASS_SUFFIX;\n        if (exportName === undefined) {\n            exportName = 'default';\n            factoryClassSuffix = '';\n        }\n        return System.import(this._config.factoryPathPrefix + module + this._config.factoryPathSuffix)\n            .then(function (module) { return module[exportName + factoryClassSuffix]; })\n            .then(function (factory) { return checkNotEmpty(factory, module, exportName); });\n    };\n    SystemJsNgModuleLoader.decorators = [\n        { type: Injectable }\n    ];\n    /** @nocollapse */\n    SystemJsNgModuleLoader.ctorParameters = function () { return [\n        { type: Compiler },\n        { type: SystemJsNgModuleLoaderConfig, decorators: [{ type: Optional }] }\n    ]; };\n    return SystemJsNgModuleLoader;\n}());\nfunction checkNotEmpty(value, modulePath, exportName) {\n    if (!value) {\n        throw new Error(\"Cannot find '\" + exportName + \"' in '\" + modulePath + \"'\");\n    }\n    return value;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Represents an Embedded Template that can be used to instantiate Embedded Views.\n *\n * You can access a `TemplateRef`, in two ways. Via a directive placed on a `<ng-template>` element\n * (or directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into\n * the constructor of the directive using the `TemplateRef` Token. Alternatively you can query for\n * the `TemplateRef` from a Component or a Directive via {@link Query}.\n *\n * To instantiate Embedded Views based on a Template, use {@link ViewContainerRef#\n * createEmbeddedView}, which will create the View and attach it to the View Container.\n *\n */\nvar TemplateRef = /** @class */ (function () {\n    function TemplateRef() {\n    }\n    return TemplateRef;\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 * 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 *\n */\nvar ViewContainerRef = /** @class */ (function () {\n    function ViewContainerRef() {\n    }\n    return ViewContainerRef;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ChangeDetectorRef = /** @class */ (function () {\n    function ChangeDetectorRef() {\n    }\n    return ChangeDetectorRef;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ViewRef = /** @class */ (function (_super) {\n    __extends(ViewRef, _super);\n    function ViewRef() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return ViewRef;\n}(ChangeDetectorRef));\n/**\n * Represents an Angular View.\n *\n * <!-- TODO: move the next two paragraphs to the dev guide -->\n * A View is a fundamental building block of the application UI. It is the smallest grouping of\n * Elements which are created and destroyed together.\n *\n * Properties of elements in a View can change, but the structure (number and order) of elements in\n * a View cannot. Changing the structure of Elements can only be done by inserting, moving or\n * removing nested Views via a `ViewContainerRef`. Each View can contain many View Containers.\n * <!-- /TODO -->\n *\n * @usageNotes\n * ### Example\n *\n * Given this template...\n *\n * ```\n * Count: {{items.length}}\n * <ul>\n *   <li *ngFor=\"let  item of items\">{{item}}</li>\n * </ul>\n * ```\n *\n * We have two `TemplateRef`s:\n *\n * Outer `TemplateRef`:\n *\n * ```\n * Count: {{items.length}}\n * <ul>\n *   <ng-template ngFor let-item [ngForOf]=\"items\"></ng-template>\n * </ul>\n * ```\n *\n * Inner `TemplateRef`:\n *\n * ```\n *   <li>{{item}}</li>\n * ```\n *\n * Notice that the original template is broken down into two separate `TemplateRef`s.\n *\n * The outer/inner `TemplateRef`s are then assembled into views like so:\n *\n * ```\n * <!-- ViewRef: outer-0 -->\n * Count: 2\n * <ul>\n *   <ng-template view-container-ref></ng-template>\n *   <!-- ViewRef: inner-1 --><li>first</li><!-- /ViewRef: inner-1 -->\n *   <!-- ViewRef: inner-2 --><li>second</li><!-- /ViewRef: inner-2 -->\n * </ul>\n * <!-- /ViewRef: outer-0 -->\n * ```\n * @experimental\n */\nvar EmbeddedViewRef = /** @class */ (function (_super) {\n    __extends(EmbeddedViewRef, _super);\n    function EmbeddedViewRef() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return EmbeddedViewRef;\n}(ViewRef));\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// Public API for compiler\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar EventListener = /** @class */ (function () {\n    function EventListener(name, callback) {\n        this.name = name;\n        this.callback = callback;\n    }\n    return EventListener;\n}());\n/**\n * @experimental All debugging apis are currently experimental.\n */\nvar DebugNode = /** @class */ (function () {\n    function DebugNode(nativeNode, parent, _debugContext) {\n        this._debugContext = _debugContext;\n        this.nativeNode = nativeNode;\n        if (parent && parent instanceof DebugElement) {\n            parent.addChild(this);\n        }\n        else {\n            this.parent = null;\n        }\n        this.listeners = [];\n    }\n    Object.defineProperty(DebugNode.prototype, \"injector\", {\n        get: function () { return this._debugContext.injector; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"componentInstance\", {\n        get: function () { return this._debugContext.component; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"context\", {\n        get: function () { return this._debugContext.context; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"references\", {\n        get: function () { return this._debugContext.references; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugNode.prototype, \"providerTokens\", {\n        get: function () { return this._debugContext.providerTokens; },\n        enumerable: true,\n        configurable: true\n    });\n    return DebugNode;\n}());\n/**\n * @experimental All debugging apis are currently experimental.\n */\nvar DebugElement = /** @class */ (function (_super) {\n    __extends(DebugElement, _super);\n    function DebugElement(nativeNode, parent, _debugContext) {\n        var _this = _super.call(this, nativeNode, parent, _debugContext) || this;\n        _this.properties = {};\n        _this.attributes = {};\n        _this.classes = {};\n        _this.styles = {};\n        _this.childNodes = [];\n        _this.nativeElement = nativeNode;\n        return _this;\n    }\n    DebugElement.prototype.addChild = function (child) {\n        if (child) {\n            this.childNodes.push(child);\n            child.parent = this;\n        }\n    };\n    DebugElement.prototype.removeChild = function (child) {\n        var childIndex = this.childNodes.indexOf(child);\n        if (childIndex !== -1) {\n            child.parent = null;\n            this.childNodes.splice(childIndex, 1);\n        }\n    };\n    DebugElement.prototype.insertChildrenAfter = function (child, newChildren) {\n        var _this = this;\n        var siblingIndex = this.childNodes.indexOf(child);\n        if (siblingIndex !== -1) {\n            (_a = this.childNodes).splice.apply(_a, __spread([siblingIndex + 1, 0], newChildren));\n            newChildren.forEach(function (c) {\n                if (c.parent) {\n                    c.parent.removeChild(c);\n                }\n                c.parent = _this;\n            });\n        }\n        var _a;\n    };\n    DebugElement.prototype.insertBefore = function (refChild, newChild) {\n        var refIndex = this.childNodes.indexOf(refChild);\n        if (refIndex === -1) {\n            this.addChild(newChild);\n        }\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    DebugElement.prototype.query = function (predicate) {\n        var results = this.queryAll(predicate);\n        return results[0] || null;\n    };\n    DebugElement.prototype.queryAll = function (predicate) {\n        var matches = [];\n        _queryElementChildren(this, predicate, matches);\n        return matches;\n    };\n    DebugElement.prototype.queryAllNodes = function (predicate) {\n        var matches = [];\n        _queryNodeChildren(this, predicate, matches);\n        return matches;\n    };\n    Object.defineProperty(DebugElement.prototype, \"children\", {\n        get: function () {\n            return this.childNodes.filter(function (node) { return node instanceof DebugElement; });\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DebugElement.prototype.triggerEventHandler = function (eventName, eventObj) {\n        this.listeners.forEach(function (listener) {\n            if (listener.name == eventName) {\n                listener.callback(eventObj);\n            }\n        });\n    };\n    return DebugElement;\n}(DebugNode));\n/**\n * @experimental\n */\nfunction asNativeElements(debugEls) {\n    return debugEls.map(function (el) { return el.nativeElement; });\n}\nfunction _queryElementChildren(element, predicate, matches) {\n    element.childNodes.forEach(function (node) {\n        if (node instanceof DebugElement) {\n            if (predicate(node)) {\n                matches.push(node);\n            }\n            _queryElementChildren(node, predicate, matches);\n        }\n    });\n}\nfunction _queryNodeChildren(parentNode, predicate, matches) {\n    if (parentNode instanceof DebugElement) {\n        parentNode.childNodes.forEach(function (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// Need to keep the nodes in a global Map so that multiple angular apps are supported.\nvar _nativeNodeToDebugNode = new Map();\n/**\n * @experimental\n */\nfunction getDebugNode(nativeNode) {\n    return _nativeNodeToDebugNode.get(nativeNode) || null;\n}\n\nfunction indexDebugNode(node) {\n    _nativeNodeToDebugNode.set(node.nativeNode, node);\n}\nfunction removeDebugNodeFromIndex(node) {\n    _nativeNodeToDebugNode.delete(node.nativeNode);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction devModeEqual(a, b) {\n    var isListLikeIterableA = isListLikeIterable(a);\n    var isListLikeIterableB = isListLikeIterable(b);\n    if (isListLikeIterableA && isListLikeIterableB) {\n        return areIterablesEqual(a, b, devModeEqual);\n    }\n    else {\n        var isAObject = a && (typeof a === 'object' || typeof a === 'function');\n        var isBObject = b && (typeof b === 'object' || typeof b === 'function');\n        if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {\n            return true;\n        }\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 has not changed.\n *\n * Wrapped values are unwrapped automatically during the change detection, and the unwrapped value\n * is 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 *\n */\nvar WrappedValue = /** @class */ (function () {\n    function WrappedValue(value) {\n        this.wrapped = value;\n    }\n    /** Creates a wrapped value. */\n    WrappedValue.wrap = function (value) { return new WrappedValue(value); };\n    /**\n     * Returns the underlying value of a wrapped value.\n     * Returns the given `value` when it is not wrapped.\n     **/\n    WrappedValue.unwrap = function (value) { return WrappedValue.isWrapped(value) ? value.wrapped : value; };\n    /** Returns true if `value` is a wrapped value. */\n    WrappedValue.isWrapped = function (value) { return value instanceof WrappedValue; };\n    return WrappedValue;\n}());\n/**\n * Represents a basic change from a previous to a new value.\n *\n */\nvar SimpleChange = /** @class */ (function () {\n    function SimpleChange(previousValue, currentValue, firstChange) {\n        this.previousValue = previousValue;\n        this.currentValue = currentValue;\n        this.firstChange = firstChange;\n    }\n    /**\n     * Check whether the new value is the first value assigned.\n     */\n    SimpleChange.prototype.isFirstChange = function () { return this.firstChange; };\n    return SimpleChange;\n}());\nfunction isListLikeIterable(obj) {\n    if (!isJsObject(obj))\n        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}\nfunction areIterablesEqual(a, b, comparator) {\n    var iterator1 = a[getSymbolIterator()]();\n    var iterator2 = b[getSymbolIterator()]();\n    while (true) {\n        var item1 = iterator1.next();\n        var item2 = iterator2.next();\n        if (item1.done && item2.done)\n            return true;\n        if (item1.done || item2.done)\n            return false;\n        if (!comparator(item1.value, item2.value))\n            return false;\n    }\n}\nfunction iterateListLike(obj, fn) {\n    if (Array.isArray(obj)) {\n        for (var i = 0; i < obj.length; i++) {\n            fn(obj[i]);\n        }\n    }\n    else {\n        var iterator = obj[getSymbolIterator()]();\n        var item = void 0;\n        while (!((item = iterator.next()).done)) {\n            fn(item.value);\n        }\n    }\n}\nfunction isJsObject(o) {\n    return o !== null && (typeof o === 'function' || typeof o === 'object');\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar DefaultIterableDifferFactory = /** @class */ (function () {\n    function DefaultIterableDifferFactory() {\n    }\n    DefaultIterableDifferFactory.prototype.supports = function (obj) { return isListLikeIterable(obj); };\n    DefaultIterableDifferFactory.prototype.create = function (trackByFn) {\n        return new DefaultIterableDiffer(trackByFn);\n    };\n    return DefaultIterableDifferFactory;\n}());\nvar trackByIdentity = function (index, item) { return item; };\n/**\n * @deprecated v4.0.0 - Should not be part of public API.\n */\nvar DefaultIterableDiffer = /** @class */ (function () {\n    function DefaultIterableDiffer(trackByFn) {\n        this.length = 0;\n        // Keeps track of the used records at any point in time (during & across `_check()` calls)\n        this._linkedRecords = null;\n        // Keeps track of the removed records at any point in time during `_check()` calls.\n        this._unlinkedRecords = null;\n        this._previousItHead = null;\n        this._itHead = null;\n        this._itTail = null;\n        this._additionsHead = null;\n        this._additionsTail = null;\n        this._movesHead = null;\n        this._movesTail = null;\n        this._removalsHead = null;\n        this._removalsTail = null;\n        // Keeps track of records where custom track by is the same, but item identity has changed\n        this._identityChangesHead = null;\n        this._identityChangesTail = null;\n        this._trackByFn = trackByFn || trackByIdentity;\n    }\n    DefaultIterableDiffer.prototype.forEachItem = function (fn) {\n        var record;\n        for (record = this._itHead; record !== null; record = record._next) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachOperation = function (fn) {\n        var nextIt = this._itHead;\n        var nextRemove = this._removalsHead;\n        var addRemoveOffset = 0;\n        var moveOffsets = null;\n        while (nextIt || nextRemove) {\n            // Figure out which is the next record to process\n            // Order: remove, add, move\n            var record = !nextRemove ||\n                nextIt &&\n                    nextIt.currentIndex <\n                        getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ?\n                nextIt :\n                nextRemove;\n            var adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);\n            var currentIndex = record.currentIndex;\n            // consume the item, and adjust the addRemoveOffset and update moveDistance if necessary\n            if (record === nextRemove) {\n                addRemoveOffset--;\n                nextRemove = nextRemove._nextRemoved;\n            }\n            else {\n                nextIt = nextIt._next;\n                if (record.previousIndex == null) {\n                    addRemoveOffset++;\n                }\n                else {\n                    // INVARIANT:  currentIndex < previousIndex\n                    if (!moveOffsets)\n                        moveOffsets = [];\n                    var localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;\n                    var localCurrentIndex = currentIndex - addRemoveOffset;\n                    if (localMovePreviousIndex != localCurrentIndex) {\n                        for (var i = 0; i < localMovePreviousIndex; i++) {\n                            var offset = i < moveOffsets.length ? moveOffsets[i] : (moveOffsets[i] = 0);\n                            var index = offset + i;\n                            if (localCurrentIndex <= index && index < localMovePreviousIndex) {\n                                moveOffsets[i] = offset + 1;\n                            }\n                        }\n                        var previousIndex = record.previousIndex;\n                        moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;\n                    }\n                }\n            }\n            if (adjPreviousIndex !== currentIndex) {\n                fn(record, adjPreviousIndex, currentIndex);\n            }\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachPreviousItem = function (fn) {\n        var record;\n        for (record = this._previousItHead; record !== null; record = record._nextPrevious) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachAddedItem = function (fn) {\n        var record;\n        for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachMovedItem = function (fn) {\n        var record;\n        for (record = this._movesHead; record !== null; record = record._nextMoved) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachRemovedItem = function (fn) {\n        var record;\n        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.forEachIdentityChange = function (fn) {\n        var record;\n        for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {\n            fn(record);\n        }\n    };\n    DefaultIterableDiffer.prototype.diff = function (collection) {\n        if (collection == null)\n            collection = [];\n        if (!isListLikeIterable(collection)) {\n            throw new Error(\"Error trying to diff '\" + stringify(collection) + \"'. Only arrays and iterables are allowed\");\n        }\n        if (this.check(collection)) {\n            return this;\n        }\n        else {\n            return null;\n        }\n    };\n    DefaultIterableDiffer.prototype.onDestroy = function () { };\n    DefaultIterableDiffer.prototype.check = function (collection) {\n        var _this = this;\n        this._reset();\n        var record = this._itHead;\n        var mayBeDirty = false;\n        var index;\n        var item;\n        var itemTrackBy;\n        if (Array.isArray(collection)) {\n            this.length = collection.length;\n            for (var index_1 = 0; index_1 < this.length; index_1++) {\n                item = collection[index_1];\n                itemTrackBy = this._trackByFn(index_1, item);\n                if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {\n                    record = this._mismatch(record, item, itemTrackBy, index_1);\n                    mayBeDirty = true;\n                }\n                else {\n                    if (mayBeDirty) {\n                        // TODO(misko): can we limit this to duplicates only?\n                        record = this._verifyReinsertion(record, item, itemTrackBy, index_1);\n                    }\n                    if (!looseIdentical(record.item, item))\n                        this._addIdentityChange(record, item);\n                }\n                record = record._next;\n            }\n        }\n        else {\n            index = 0;\n            iterateListLike(collection, function (item) {\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                }\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))\n                        _this._addIdentityChange(record, item);\n                }\n                record = record._next;\n                index++;\n            });\n            this.length = index;\n        }\n        this._truncate(record);\n        this.collection = collection;\n        return this.isDirty;\n    };\n    Object.defineProperty(DefaultIterableDiffer.prototype, \"isDirty\", {\n        /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity\n         * changes.\n         */\n        get: function () {\n            return this._additionsHead !== null || this._movesHead !== null ||\n                this._removalsHead !== null || this._identityChangesHead !== null;\n        },\n        enumerable: true,\n        configurable: true\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     */\n    DefaultIterableDiffer.prototype._reset = function () {\n        if (this.isDirty) {\n            var record = void 0;\n            var nextRecord = void 0;\n            for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {\n                record._nextPrevious = record._next;\n            }\n            for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n                record.previousIndex = record.currentIndex;\n            }\n            this._additionsHead = this._additionsTail = null;\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            // 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     */\n    DefaultIterableDiffer.prototype._mismatch = function (record, item, itemTrackBy, index) {\n        // The previous record after which we will append the current one.\n        var previousRecord;\n        if (record === null) {\n            previousRecord = this._itTail;\n        }\n        else {\n            previousRecord = record._prev;\n            // Remove the record from the collection since we know it does not match the item.\n            this._remove(record);\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))\n                this._addIdentityChange(record, item);\n            this._moveAfter(record, previousRecord, index);\n        }\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))\n                    this._addIdentityChange(record, item);\n                this._reinsertAfter(record, previousRecord, index);\n            }\n            else {\n                // It is a new item: add it.\n                record =\n                    this._addAfter(new IterableChangeRecord_(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     */\n    DefaultIterableDiffer.prototype._verifyReinsertion = function (record, item, itemTrackBy, index) {\n        var reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);\n        if (reinsertRecord !== null) {\n            record = this._reinsertAfter(reinsertRecord, record._prev, index);\n        }\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     */\n    DefaultIterableDiffer.prototype._truncate = function (record) {\n        // Anything after that needs to be removed;\n        while (record !== null) {\n            var nextRecord = record._next;\n            this._addToRemovals(this._unlink(record));\n            record = nextRecord;\n        }\n        if (this._unlinkedRecords !== null) {\n            this._unlinkedRecords.clear();\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    /** @internal */\n    DefaultIterableDiffer.prototype._reinsertAfter = function (record, prevRecord, index) {\n        if (this._unlinkedRecords !== null) {\n            this._unlinkedRecords.remove(record);\n        }\n        var prev = record._prevRemoved;\n        var next = record._nextRemoved;\n        if (prev === null) {\n            this._removalsHead = next;\n        }\n        else {\n            prev._nextRemoved = next;\n        }\n        if (next === null) {\n            this._removalsTail = prev;\n        }\n        else {\n            next._prevRemoved = prev;\n        }\n        this._insertAfter(record, prevRecord, index);\n        this._addToMoves(record, index);\n        return record;\n    };\n    /** @internal */\n    DefaultIterableDiffer.prototype._moveAfter = function (record, prevRecord, index) {\n        this._unlink(record);\n        this._insertAfter(record, prevRecord, index);\n        this._addToMoves(record, index);\n        return record;\n    };\n    /** @internal */\n    DefaultIterableDiffer.prototype._addAfter = function (record, prevRecord, index) {\n        this._insertAfter(record, prevRecord, index);\n        if (this._additionsTail === null) {\n            // TODO(vicb):\n            // assert(this._additionsHead === null);\n            this._additionsTail = this._additionsHead = record;\n        }\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    /** @internal */\n    DefaultIterableDiffer.prototype._insertAfter = function (record, prevRecord, index) {\n        // TODO(vicb):\n        // assert(record != prevRecord);\n        // assert(record._next === null);\n        // assert(record._prev === null);\n        var next = 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        }\n        else {\n            next._prev = record;\n        }\n        if (prevRecord === null) {\n            this._itHead = record;\n        }\n        else {\n            prevRecord._next = record;\n        }\n        if (this._linkedRecords === null) {\n            this._linkedRecords = new _DuplicateMap();\n        }\n        this._linkedRecords.put(record);\n        record.currentIndex = index;\n        return record;\n    };\n    /** @internal */\n    DefaultIterableDiffer.prototype._remove = function (record) {\n        return this._addToRemovals(this._unlink(record));\n    };\n    /** @internal */\n    DefaultIterableDiffer.prototype._unlink = function (record) {\n        if (this._linkedRecords !== null) {\n            this._linkedRecords.remove(record);\n        }\n        var prev = record._prev;\n        var next = record._next;\n        // TODO(vicb):\n        // assert((record._prev = null) === null);\n        // assert((record._next = null) === null);\n        if (prev === null) {\n            this._itHead = next;\n        }\n        else {\n            prev._next = next;\n        }\n        if (next === null) {\n            this._itTail = prev;\n        }\n        else {\n            next._prev = prev;\n        }\n        return record;\n    };\n    /** @internal */\n    DefaultIterableDiffer.prototype._addToMoves = function (record, toIndex) {\n        // TODO(vicb):\n        // assert(record._nextMoved === null);\n        if (record.previousIndex === toIndex) {\n            return record;\n        }\n        if (this._movesTail === null) {\n            // TODO(vicb):\n            // assert(_movesHead === null);\n            this._movesTail = this._movesHead = record;\n        }\n        else {\n            // TODO(vicb):\n            // assert(_movesTail._nextMoved === null);\n            this._movesTail = this._movesTail._nextMoved = record;\n        }\n        return record;\n    };\n    DefaultIterableDiffer.prototype._addToRemovals = function (record) {\n        if (this._unlinkedRecords === null) {\n            this._unlinkedRecords = new _DuplicateMap();\n        }\n        this._unlinkedRecords.put(record);\n        record.currentIndex = null;\n        record._nextRemoved = null;\n        if (this._removalsTail === null) {\n            // TODO(vicb):\n            // assert(_removalsHead === null);\n            this._removalsTail = this._removalsHead = record;\n            record._prevRemoved = null;\n        }\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    /** @internal */\n    DefaultIterableDiffer.prototype._addIdentityChange = function (record, item) {\n        record.item = item;\n        if (this._identityChangesTail === null) {\n            this._identityChangesTail = this._identityChangesHead = record;\n        }\n        else {\n            this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;\n        }\n        return record;\n    };\n    return DefaultIterableDiffer;\n}());\nvar IterableChangeRecord_ = /** @class */ (function () {\n    function IterableChangeRecord_(item, trackById) {\n        this.item = item;\n        this.trackById = trackById;\n        this.currentIndex = null;\n        this.previousIndex = null;\n        /** @internal */\n        this._nextPrevious = null;\n        /** @internal */\n        this._prev = null;\n        /** @internal */\n        this._next = null;\n        /** @internal */\n        this._prevDup = null;\n        /** @internal */\n        this._nextDup = null;\n        /** @internal */\n        this._prevRemoved = null;\n        /** @internal */\n        this._nextRemoved = null;\n        /** @internal */\n        this._nextAdded = null;\n        /** @internal */\n        this._nextMoved = null;\n        /** @internal */\n        this._nextIdentityChange = null;\n    }\n    return IterableChangeRecord_;\n}());\n// A linked list of CollectionChangeRecords with the same IterableChangeRecord_.item\nvar _DuplicateItemRecordList = /** @class */ (function () {\n    function _DuplicateItemRecordList() {\n        /** @internal */\n        this._head = null;\n        /** @internal */\n        this._tail = null;\n    }\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     */\n    _DuplicateItemRecordList.prototype.add = function (record) {\n        if (this._head === null) {\n            this._head = this._tail = record;\n            record._nextDup = null;\n            record._prevDup = null;\n        }\n        else {\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    // Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and\n    // IterableChangeRecord_.currentIndex >= atOrAfterIndex\n    _DuplicateItemRecordList.prototype.get = function (trackById, atOrAfterIndex) {\n        var record;\n        for (record = this._head; record !== null; record = record._nextDup) {\n            if ((atOrAfterIndex === null || atOrAfterIndex <= 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     */\n    _DuplicateItemRecordList.prototype.remove = function (record) {\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        var prev = record._prevDup;\n        var next = record._nextDup;\n        if (prev === null) {\n            this._head = next;\n        }\n        else {\n            prev._nextDup = next;\n        }\n        if (next === null) {\n            this._tail = prev;\n        }\n        else {\n            next._prevDup = prev;\n        }\n        return this._head === null;\n    };\n    return _DuplicateItemRecordList;\n}());\nvar _DuplicateMap = /** @class */ (function () {\n    function _DuplicateMap() {\n        this.map = new Map();\n    }\n    _DuplicateMap.prototype.put = function (record) {\n        var key = record.trackById;\n        var duplicates = this.map.get(key);\n        if (!duplicates) {\n            duplicates = new _DuplicateItemRecordList();\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 `atOrAfterIndex` 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 second `a`.\n     */\n    _DuplicateMap.prototype.get = function (trackById, atOrAfterIndex) {\n        var key = trackById;\n        var recordList = this.map.get(key);\n        return recordList ? recordList.get(trackById, atOrAfterIndex) : 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     */\n    _DuplicateMap.prototype.remove = function (record) {\n        var key = record.trackById;\n        var recordList = 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    Object.defineProperty(_DuplicateMap.prototype, \"isEmpty\", {\n        get: function () { return this.map.size === 0; },\n        enumerable: true,\n        configurable: true\n    });\n    _DuplicateMap.prototype.clear = function () { this.map.clear(); };\n    return _DuplicateMap;\n}());\nfunction getPreviousIndex(item, addRemoveOffset, moveOffsets) {\n    var previousIndex = item.previousIndex;\n    if (previousIndex === null)\n        return previousIndex;\n    var moveOffset = 0;\n    if (moveOffsets && previousIndex < moveOffsets.length) {\n        moveOffset = moveOffsets[previousIndex];\n    }\n    return previousIndex + addRemoveOffset + moveOffset;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar DefaultKeyValueDifferFactory = /** @class */ (function () {\n    function DefaultKeyValueDifferFactory() {\n    }\n    DefaultKeyValueDifferFactory.prototype.supports = function (obj) { return obj instanceof Map || isJsObject(obj); };\n    DefaultKeyValueDifferFactory.prototype.create = function () { return new DefaultKeyValueDiffer(); };\n    return DefaultKeyValueDifferFactory;\n}());\nvar DefaultKeyValueDiffer = /** @class */ (function () {\n    function DefaultKeyValueDiffer() {\n        this._records = new Map();\n        this._mapHead = null;\n        // _appendAfter is used in the check loop\n        this._appendAfter = null;\n        this._previousMapHead = null;\n        this._changesHead = null;\n        this._changesTail = null;\n        this._additionsHead = null;\n        this._additionsTail = null;\n        this._removalsHead = null;\n        this._removalsTail = null;\n    }\n    Object.defineProperty(DefaultKeyValueDiffer.prototype, \"isDirty\", {\n        get: function () {\n            return this._additionsHead !== null || this._changesHead !== null ||\n                this._removalsHead !== null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DefaultKeyValueDiffer.prototype.forEachItem = function (fn) {\n        var record;\n        for (record = this._mapHead; record !== null; record = record._next) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachPreviousItem = function (fn) {\n        var record;\n        for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachChangedItem = function (fn) {\n        var record;\n        for (record = this._changesHead; record !== null; record = record._nextChanged) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachAddedItem = function (fn) {\n        var record;\n        for (record = this._additionsHead; record !== null; record = record._nextAdded) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.forEachRemovedItem = function (fn) {\n        var record;\n        for (record = this._removalsHead; record !== null; record = record._nextRemoved) {\n            fn(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype.diff = function (map) {\n        if (!map) {\n            map = new Map();\n        }\n        else if (!(map instanceof Map || isJsObject(map))) {\n            throw new Error(\"Error trying to diff '\" + stringify(map) + \"'. Only maps and objects are allowed\");\n        }\n        return this.check(map) ? this : null;\n    };\n    DefaultKeyValueDiffer.prototype.onDestroy = function () { };\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     */\n    DefaultKeyValueDiffer.prototype.check = function (map) {\n        var _this = this;\n        this._reset();\n        var insertBefore = this._mapHead;\n        this._appendAfter = null;\n        this._forEach(map, function (value, key) {\n            if (insertBefore && insertBefore.key === key) {\n                _this._maybeAddToChanges(insertBefore, value);\n                _this._appendAfter = insertBefore;\n                insertBefore = insertBefore._next;\n            }\n            else {\n                var record = _this._getOrCreateRecordForKey(key, value);\n                insertBefore = _this._insertBeforeOrAppend(insertBefore, record);\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            this._removalsHead = insertBefore;\n            for (var record = insertBefore; record !== null; 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        // Make sure tails have no next records from previous runs\n        if (this._changesTail)\n            this._changesTail._nextChanged = null;\n        if (this._additionsTail)\n            this._additionsTail._nextAdded = null;\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     */\n    DefaultKeyValueDiffer.prototype._insertBeforeOrAppend = function (before, record) {\n        if (before) {\n            var 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            this._appendAfter = before;\n            return before;\n        }\n        if (this._appendAfter) {\n            this._appendAfter._next = record;\n            record._prev = this._appendAfter;\n        }\n        else {\n            this._mapHead = record;\n        }\n        this._appendAfter = record;\n        return null;\n    };\n    DefaultKeyValueDiffer.prototype._getOrCreateRecordForKey = function (key, value) {\n        if (this._records.has(key)) {\n            var record_1 = this._records.get(key);\n            this._maybeAddToChanges(record_1, value);\n            var prev = record_1._prev;\n            var next = record_1._next;\n            if (prev) {\n                prev._next = next;\n            }\n            if (next) {\n                next._prev = prev;\n            }\n            record_1._next = null;\n            record_1._prev = null;\n            return record_1;\n        }\n        var record = new KeyValueChangeRecord_(key);\n        this._records.set(key, record);\n        record.currentValue = value;\n        this._addToAdditions(record);\n        return record;\n    };\n    /** @internal */\n    DefaultKeyValueDiffer.prototype._reset = function () {\n        if (this.isDirty) {\n            var record = void 0;\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            // 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            this._changesHead = this._changesTail = null;\n            this._additionsHead = this._additionsTail = null;\n            this._removalsHead = null;\n        }\n    };\n    // Add the record or a given key to the list of changes only when the value has actually changed\n    DefaultKeyValueDiffer.prototype._maybeAddToChanges = function (record, newValue) {\n        if (!looseIdentical(newValue, record.currentValue)) {\n            record.previousValue = record.currentValue;\n            record.currentValue = newValue;\n            this._addToChanges(record);\n        }\n    };\n    DefaultKeyValueDiffer.prototype._addToAdditions = function (record) {\n        if (this._additionsHead === null) {\n            this._additionsHead = this._additionsTail = record;\n        }\n        else {\n            this._additionsTail._nextAdded = record;\n            this._additionsTail = record;\n        }\n    };\n    DefaultKeyValueDiffer.prototype._addToChanges = function (record) {\n        if (this._changesHead === null) {\n            this._changesHead = this._changesTail = record;\n        }\n        else {\n            this._changesTail._nextChanged = record;\n            this._changesTail = record;\n        }\n    };\n    /** @internal */\n    DefaultKeyValueDiffer.prototype._forEach = function (obj, fn) {\n        if (obj instanceof Map) {\n            obj.forEach(fn);\n        }\n        else {\n            Object.keys(obj).forEach(function (k) { return fn(obj[k], k); });\n        }\n    };\n    return DefaultKeyValueDiffer;\n}());\nvar KeyValueChangeRecord_ = /** @class */ (function () {\n    function KeyValueChangeRecord_(key) {\n        this.key = key;\n        this.previousValue = null;\n        this.currentValue = null;\n        /** @internal */\n        this._nextPrevious = null;\n        /** @internal */\n        this._next = null;\n        /** @internal */\n        this._prev = null;\n        /** @internal */\n        this._nextAdded = null;\n        /** @internal */\n        this._nextRemoved = null;\n        /** @internal */\n        this._nextChanged = null;\n    }\n    return KeyValueChangeRecord_;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.\n *\n */\nvar IterableDiffers = /** @class */ (function () {\n    function IterableDiffers(factories) {\n        this.factories = factories;\n    }\n    IterableDiffers.create = function (factories, parent) {\n        if (parent != null) {\n            var copied = parent.factories.slice();\n            factories = factories.concat(copied);\n        }\n        return new IterableDiffers(factories);\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     * @usageNotes\n     * ### Example\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     * ```\n     * @Component({\n     *   viewProviders: [\n     *     IterableDiffers.extend([new ImmutableListDiffer()])\n     *   ]\n     * })\n     * ```\n     */\n    IterableDiffers.extend = function (factories) {\n        return {\n            provide: IterableDiffers,\n            useFactory: function (parent) {\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    IterableDiffers.prototype.find = function (iterable) {\n        var factory = this.factories.find(function (f) { return f.supports(iterable); });\n        if (factory != null) {\n            return factory;\n        }\n        else {\n            throw new Error(\"Cannot find a differ supporting object '\" + iterable + \"' of type '\" + getTypeNameForDebugging(iterable) + \"'\");\n        }\n    };\n    IterableDiffers.ngInjectableDef = defineInjectable({\n        providedIn: 'root',\n        factory: function () { return new IterableDiffers([new DefaultIterableDifferFactory()]); }\n    });\n    return IterableDiffers;\n}());\nfunction getTypeNameForDebugging(type) {\n    return type['name'] || typeof type;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.\n *\n */\nvar KeyValueDiffers = /** @class */ (function () {\n    function KeyValueDiffers(factories) {\n        this.factories = factories;\n    }\n    KeyValueDiffers.create = function (factories, parent) {\n        if (parent) {\n            var 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     * @usageNotes\n     * ### Example\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     * ```\n     * @Component({\n     *   viewProviders: [\n     *     KeyValueDiffers.extend([new ImmutableMapDiffer()])\n     *   ]\n     * })\n     * ```\n     */\n    KeyValueDiffers.extend = function (factories) {\n        return {\n            provide: KeyValueDiffers,\n            useFactory: function (parent) {\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    KeyValueDiffers.prototype.find = function (kv) {\n        var factory = this.factories.find(function (f) { return f.supports(kv); });\n        if (factory) {\n            return factory;\n        }\n        throw new Error(\"Cannot find a differ supporting object '\" + kv + \"'\");\n    };\n    return KeyValueDiffers;\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 * Structural diffing for `Object`s and `Map`s.\n */\nvar keyValDiff = [new DefaultKeyValueDifferFactory()];\n/**\n * Structural diffing for `Iterable` types such as `Array`s.\n */\nvar iterableDiff = [new DefaultIterableDifferFactory()];\nvar defaultIterableDiffers = new IterableDiffers(iterableDiff);\nvar defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);\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 * @module\n * @description\n * Change detection enables data binding in Angular.\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _CORE_PLATFORM_PROVIDERS = [\n    // Set a default platform name for platforms that don't set it explicitly.\n    { provide: PLATFORM_ID, useValue: 'unknown' },\n    { provide: PlatformRef, deps: [Injector] },\n    { provide: TestabilityRegistry, deps: [] },\n    { provide: Console, deps: [] },\n];\n/**\n * This platform has to be included in any other platform\n *\n * @experimental\n */\nvar platformCore = createPlatformFactory(null, 'core', _CORE_PLATFORM_PROVIDERS);\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 * Provide this token to set the locale of your application.\n * It is used for i18n extraction, by i18n pipes (DatePipe, I18nPluralPipe, CurrencyPipe,\n * DecimalPipe and PercentPipe) and by ICU expressions.\n *\n * See the [i18n guide](guide/i18n#setting-up-locale) for more information.\n *\n * @usageNotes\n * ### Example\n *\n * ```typescript\n * import { LOCALE_ID } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   providers: [{provide: LOCALE_ID, useValue: 'en-US' }]\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\nvar LOCALE_ID = new InjectionToken('LocaleId');\n/**\n * Use this token at bootstrap to provide the content of your translation file (`xtb`,\n * `xlf` or `xlf2`) when you want to translate your application in another language.\n *\n * See the [i18n guide](guide/i18n#merge) for more information.\n *\n * @usageNotes\n * ### Example\n *\n * ```typescript\n * import { TRANSLATIONS } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * // content of your translation file\n * const translations = '....';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   providers: [{provide: TRANSLATIONS, useValue: translations }]\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\nvar TRANSLATIONS = new InjectionToken('Translations');\n/**\n * Provide this token at bootstrap to set the format of your {@link TRANSLATIONS}: `xtb`,\n * `xlf` or `xlf2`.\n *\n * See the [i18n guide](guide/i18n#merge) for more information.\n *\n * @usageNotes\n * ### Example\n *\n * ```typescript\n * import { TRANSLATIONS_FORMAT } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   providers: [{provide: TRANSLATIONS_FORMAT, useValue: 'xlf' }]\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\nvar TRANSLATIONS_FORMAT = new InjectionToken('TranslationsFormat');\n/**\n * Use this enum at bootstrap as an option of `bootstrapModule` to define the strategy\n * that the compiler should use in case of missing translations:\n * - Error: throw if you have missing translations.\n * - Warning (default): show a warning in the console and/or shell.\n * - Ignore: do nothing.\n *\n * See the [i18n guide](guide/i18n#missing-translation) for more information.\n *\n * @usageNotes\n * ### Example\n * ```typescript\n * import { MissingTranslationStrategy } from '@angular/core';\n * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\n * import { AppModule } from './app/app.module';\n *\n * platformBrowserDynamic().bootstrapModule(AppModule, {\n *   missingTranslation: MissingTranslationStrategy.Error\n * });\n * ```\n *\n * @experimental i18n support is experimental.\n */\n\n(function (MissingTranslationStrategy) {\n    MissingTranslationStrategy[MissingTranslationStrategy[\"Error\"] = 0] = \"Error\";\n    MissingTranslationStrategy[MissingTranslationStrategy[\"Warning\"] = 1] = \"Warning\";\n    MissingTranslationStrategy[MissingTranslationStrategy[\"Ignore\"] = 2] = \"Ignore\";\n})(exports.MissingTranslationStrategy || (exports.MissingTranslationStrategy = {}));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction _iterableDiffersFactory() {\n    return defaultIterableDiffers;\n}\nfunction _keyValueDiffersFactory() {\n    return defaultKeyValueDiffers;\n}\nfunction _localeFactory(locale) {\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 */\nvar ApplicationModule = /** @class */ (function () {\n    // Inject ApplicationRef to make it eager...\n    function ApplicationModule(appRef) {\n    }\n    ApplicationModule.decorators = [\n        { type: NgModule, args: [{\n                    providers: [\n                        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    /** @nocollapse */\n    ApplicationModule.ctorParameters = function () { return [\n        { type: ApplicationRef }\n    ]; };\n    return ApplicationModule;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This helper class is used to get hold of an inert tree of DOM elements containing dirty HTML\n * that needs sanitizing.\n * Depending upon browser support we must use one of three strategies for doing this.\n * Support: Safari 10.x -> XHR strategy\n * Support: Firefox -> DomParser strategy\n * Default: InertDocument strategy\n */\nvar InertBodyHelper = /** @class */ (function () {\n    function InertBodyHelper(defaultDoc) {\n        this.defaultDoc = defaultDoc;\n        this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');\n        this.inertBodyElement = this.inertDocument.body;\n        if (this.inertBodyElement == null) {\n            // usually there should be only one body element in the document, but IE doesn't have any, so\n            // we need to create one.\n            var inertHtml = this.inertDocument.createElement('html');\n            this.inertDocument.appendChild(inertHtml);\n            this.inertBodyElement = this.inertDocument.createElement('body');\n            inertHtml.appendChild(this.inertBodyElement);\n        }\n        this.inertBodyElement.innerHTML = '<svg><g onload=\"this.parentNode.remove()\"></g></svg>';\n        if (this.inertBodyElement.querySelector && !this.inertBodyElement.querySelector('svg')) {\n            // We just hit the Safari 10.1 bug - which allows JS to run inside the SVG G element\n            // so use the XHR strategy.\n            this.getInertBodyElement = this.getInertBodyElement_XHR;\n            return;\n        }\n        this.inertBodyElement.innerHTML =\n            '<svg><p><style><img src=\"</style><img src=x onerror=alert(1)//\">';\n        if (this.inertBodyElement.querySelector && this.inertBodyElement.querySelector('svg img')) {\n            // We just hit the Firefox bug - which prevents the inner img JS from being sanitized\n            // so use the DOMParser strategy, if it is available.\n            // If the DOMParser is not available then we are not in Firefox (Server/WebWorker?) so we\n            // fall through to the default strategy below.\n            if (isDOMParserAvailable()) {\n                this.getInertBodyElement = this.getInertBodyElement_DOMParser;\n                return;\n            }\n        }\n        // None of the bugs were hit so it is safe for us to use the default InertDocument strategy\n        this.getInertBodyElement = this.getInertBodyElement_InertDocument;\n    }\n    /**\n     * Use XHR to create and fill an inert body element (on Safari 10.1)\n     * See\n     * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449\n     */\n    InertBodyHelper.prototype.getInertBodyElement_XHR = function (html) {\n        // We add these extra elements to ensure that the rest of the content is parsed as expected\n        // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the\n        // `<head>` tag.\n        html = '<body><remove></remove>' + html + '</body>';\n        try {\n            html = encodeURI(html);\n        }\n        catch (e) {\n            return null;\n        }\n        var xhr = new XMLHttpRequest();\n        xhr.responseType = 'document';\n        xhr.open('GET', 'data:text/html;charset=utf-8,' + html, false);\n        xhr.send(null);\n        var body = xhr.response.body;\n        body.removeChild(body.firstChild);\n        return body;\n    };\n    /**\n     * Use DOMParser to create and fill an inert body element (on Firefox)\n     * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7\n     *\n     */\n    InertBodyHelper.prototype.getInertBodyElement_DOMParser = function (html) {\n        // We add these extra elements to ensure that the rest of the content is parsed as expected\n        // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the\n        // `<head>` tag.\n        html = '<body><remove></remove>' + html + '</body>';\n        try {\n            var body = new window\n                .DOMParser()\n                .parseFromString(html, 'text/html')\n                .body;\n            body.removeChild(body.firstChild);\n            return body;\n        }\n        catch (e) {\n            return null;\n        }\n    };\n    /**\n     * Use an HTML5 `template` element, if supported, or an inert body element created via\n     * `createHtmlDocument` to create and fill an inert DOM element.\n     * This is the default sane strategy to use if the browser does not require one of the specialised\n     * strategies above.\n     */\n    InertBodyHelper.prototype.getInertBodyElement_InertDocument = function (html) {\n        // Prefer using <template> element if supported.\n        var templateEl = this.inertDocument.createElement('template');\n        if ('content' in templateEl) {\n            templateEl.innerHTML = html;\n            return templateEl;\n        }\n        this.inertBodyElement.innerHTML = html;\n        // Support: IE 9-11 only\n        // strip custom-namespaced attributes on IE<=11\n        if (this.defaultDoc.documentMode) {\n            this.stripCustomNsAttrs(this.inertBodyElement);\n        }\n        return this.inertBodyElement;\n    };\n    /**\n     * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'\n     * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.\n     * 'ns1:xlink:foo').\n     *\n     * This is undesirable since we don't want to allow any of these custom attributes. This method\n     * strips them all.\n     */\n    InertBodyHelper.prototype.stripCustomNsAttrs = function (el) {\n        var elAttrs = el.attributes;\n        // loop backwards so that we can support removals.\n        for (var i = elAttrs.length - 1; 0 < i; i--) {\n            var attrib = elAttrs.item(i);\n            var attrName = attrib.name;\n            if (attrName === 'xmlns:ns1' || attrName.indexOf('ns1:') === 0) {\n                el.removeAttribute(attrName);\n            }\n        }\n        var childNode = el.firstChild;\n        while (childNode) {\n            if (childNode.nodeType === Node.ELEMENT_NODE)\n                this.stripCustomNsAttrs(childNode);\n            childNode = childNode.nextSibling;\n        }\n    };\n    return InertBodyHelper;\n}());\n/**\n * We need to determine whether the DOMParser exists in the global context.\n * The try-catch is because, on some browsers, trying to access this property\n * on window can actually throw an error.\n *\n * @suppress {uselessCode}\n */\nfunction isDOMParserAvailable() {\n    try {\n        return !!window.DOMParser;\n    }\n    catch (e) {\n        return false;\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 * A pattern that recognizes a commonly useful subset of URLs that are safe.\n *\n * This regular expression matches a subset of URLs that will not cause script\n * execution if used in URL context within a HTML document. Specifically, this\n * regular expression matches if (comment from here on and regex copied from\n * Soy's EscapingConventions):\n * (1) Either a protocol in a whitelist (http, https, mailto or ftp).\n * (2) or no protocol.  A protocol must be followed by a colon. The below\n *     allows that by allowing colons only after one of the characters [/?#].\n *     A colon after a hash (#) must be in the fragment.\n *     Otherwise, a colon after a (?) must be in a query.\n *     Otherwise, a colon after a single solidus (/) must be in a path.\n *     Otherwise, a colon after a double solidus (//) must be in the authority\n *     (before port).\n *\n * The pattern disallows &, used in HTML entity declarations before\n * one of the characters in [/?#]. This disallows HTML entities used in the\n * protocol name, which should never happen, e.g. \"h&#116;tp\" for \"http\".\n * It also disallows HTML entities in the first path part of a relative path,\n * e.g. \"foo&lt;bar/baz\".  Our existing escaping functions should not produce\n * that. More importantly, it disallows masking of a colon,\n * e.g. \"javascript&#58;...\".\n *\n * This regular expression was taken from the Closure sanitization library.\n */\nvar SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi;\n/** A pattern that matches safe data URLs. Only matches image, video and audio types. */\nvar DATA_URL_PATTERN = /^data:(?:image\\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\\/(?:mpeg|mp4|ogg|webm)|audio\\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+\\/]+=*$/i;\nfunction _sanitizeUrl(url) {\n    url = String(url);\n    if (url.match(SAFE_URL_PATTERN) || url.match(DATA_URL_PATTERN))\n        return url;\n    if (isDevMode()) {\n        console.warn(\"WARNING: sanitizing unsafe URL value \" + url + \" (see http://g.co/ng/security#xss)\");\n    }\n    return 'unsafe:' + url;\n}\nfunction sanitizeSrcset(srcset) {\n    srcset = String(srcset);\n    return srcset.split(',').map(function (srcset) { return _sanitizeUrl(srcset.trim()); }).join(', ');\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction tagSet(tags) {\n    var res = {};\n    try {\n        for (var _a = __values(tags.split(',')), _b = _a.next(); !_b.done; _b = _a.next()) {\n            var t = _b.value;\n            res[t] = true;\n        }\n    }\n    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n    finally {\n        try {\n            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);\n        }\n        finally { if (e_1) throw e_1.error; }\n    }\n    return res;\n    var e_1, _c;\n}\nfunction merge$1() {\n    var sets = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sets[_i] = arguments[_i];\n    }\n    var res = {};\n    try {\n        for (var sets_1 = __values(sets), sets_1_1 = sets_1.next(); !sets_1_1.done; sets_1_1 = sets_1.next()) {\n            var s = sets_1_1.value;\n            for (var v in s) {\n                if (s.hasOwnProperty(v))\n                    res[v] = true;\n            }\n        }\n    }\n    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n    finally {\n        try {\n            if (sets_1_1 && !sets_1_1.done && (_a = sets_1.return)) _a.call(sets_1);\n        }\n        finally { if (e_2) throw e_2.error; }\n    }\n    return res;\n    var e_2, _a;\n}\n// Good source of info about elements and attributes\n// http://dev.w3.org/html5/spec/Overview.html#semantics\n// http://simon.html5.org/html-elements\n// Safe Void Elements - HTML5\n// http://dev.w3.org/html5/spec/Overview.html#void-elements\nvar VOID_ELEMENTS = tagSet('area,br,col,hr,img,wbr');\n// Elements that you can, intentionally, leave open (and which close themselves)\n// http://dev.w3.org/html5/spec/Overview.html#optional-tags\nvar OPTIONAL_END_TAG_BLOCK_ELEMENTS = tagSet('colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr');\nvar OPTIONAL_END_TAG_INLINE_ELEMENTS = tagSet('rp,rt');\nvar OPTIONAL_END_TAG_ELEMENTS = merge$1(OPTIONAL_END_TAG_INLINE_ELEMENTS, OPTIONAL_END_TAG_BLOCK_ELEMENTS);\n// Safe Block Elements - HTML5\nvar BLOCK_ELEMENTS = merge$1(OPTIONAL_END_TAG_BLOCK_ELEMENTS, tagSet('address,article,' +\n    'aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,' +\n    'h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul'));\n// Inline Elements - HTML5\nvar INLINE_ELEMENTS = merge$1(OPTIONAL_END_TAG_INLINE_ELEMENTS, tagSet('a,abbr,acronym,audio,b,' +\n    'bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,' +\n    'samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video'));\nvar VALID_ELEMENTS = merge$1(VOID_ELEMENTS, BLOCK_ELEMENTS, INLINE_ELEMENTS, OPTIONAL_END_TAG_ELEMENTS);\n// Attributes that have href and hence need to be sanitized\nvar URI_ATTRS = tagSet('background,cite,href,itemtype,longdesc,poster,src,xlink:href');\n// Attributes that have special href set hence need to be sanitized\nvar SRCSET_ATTRS = tagSet('srcset');\nvar HTML_ATTRS = tagSet('abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,' +\n    'compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,' +\n    'ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,' +\n    'scope,scrolling,shape,size,sizes,span,srclang,start,summary,tabindex,target,title,translate,type,usemap,' +\n    'valign,value,vspace,width');\n// NB: This currently consciously doesn't support SVG. SVG sanitization has had several security\n// issues in the past, so it seems safer to leave it out if possible. If support for binding SVG via\n// innerHTML is required, SVG attributes should be added here.\n// NB: Sanitization does not allow <form> elements or other active elements (<button> etc). Those\n// can be sanitized, but they increase security surface area without a legitimate use case, so they\n// are left out here.\nvar VALID_ATTRS = merge$1(URI_ATTRS, SRCSET_ATTRS, HTML_ATTRS);\n/**\n * SanitizingHtmlSerializer serializes a DOM fragment, stripping out any unsafe elements and unsafe\n * attributes.\n */\nvar SanitizingHtmlSerializer = /** @class */ (function () {\n    function SanitizingHtmlSerializer() {\n        // Explicitly track if something was stripped, to avoid accidentally warning of sanitization just\n        // because characters were re-encoded.\n        this.sanitizedSomething = false;\n        this.buf = [];\n    }\n    SanitizingHtmlSerializer.prototype.sanitizeChildren = function (el) {\n        // This cannot use a TreeWalker, as it has to run on Angular's various DOM adapters.\n        // However this code never accesses properties off of `document` before deleting its contents\n        // again, so it shouldn't be vulnerable to DOM clobbering.\n        var current = el.firstChild;\n        while (current) {\n            if (current.nodeType === Node.ELEMENT_NODE) {\n                this.startElement(current);\n            }\n            else if (current.nodeType === Node.TEXT_NODE) {\n                this.chars(current.nodeValue);\n            }\n            else {\n                // Strip non-element, non-text nodes.\n                this.sanitizedSomething = true;\n            }\n            if (current.firstChild) {\n                current = current.firstChild;\n                continue;\n            }\n            while (current) {\n                // Leaving the element. Walk up and to the right, closing tags as we go.\n                if (current.nodeType === Node.ELEMENT_NODE) {\n                    this.endElement(current);\n                }\n                var next = this.checkClobberedElement(current, current.nextSibling);\n                if (next) {\n                    current = next;\n                    break;\n                }\n                current = this.checkClobberedElement(current, current.parentNode);\n            }\n        }\n        return this.buf.join('');\n    };\n    SanitizingHtmlSerializer.prototype.startElement = function (element) {\n        var tagName = element.nodeName.toLowerCase();\n        if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {\n            this.sanitizedSomething = true;\n            return;\n        }\n        this.buf.push('<');\n        this.buf.push(tagName);\n        var elAttrs = element.attributes;\n        for (var i = 0; i < elAttrs.length; i++) {\n            var elAttr = elAttrs.item(i);\n            var attrName = elAttr.name;\n            var lower = attrName.toLowerCase();\n            if (!VALID_ATTRS.hasOwnProperty(lower)) {\n                this.sanitizedSomething = true;\n                continue;\n            }\n            var value = elAttr.value;\n            // TODO(martinprobst): Special case image URIs for data:image/...\n            if (URI_ATTRS[lower])\n                value = _sanitizeUrl(value);\n            if (SRCSET_ATTRS[lower])\n                value = sanitizeSrcset(value);\n            this.buf.push(' ', attrName, '=\"', encodeEntities(value), '\"');\n        }\n        this.buf.push('>');\n    };\n    SanitizingHtmlSerializer.prototype.endElement = function (current) {\n        var tagName = current.nodeName.toLowerCase();\n        if (VALID_ELEMENTS.hasOwnProperty(tagName) && !VOID_ELEMENTS.hasOwnProperty(tagName)) {\n            this.buf.push('</');\n            this.buf.push(tagName);\n            this.buf.push('>');\n        }\n    };\n    SanitizingHtmlSerializer.prototype.chars = function (chars) { this.buf.push(encodeEntities(chars)); };\n    SanitizingHtmlSerializer.prototype.checkClobberedElement = function (node, nextNode) {\n        if (nextNode &&\n            (node.compareDocumentPosition(nextNode) &\n                Node.DOCUMENT_POSITION_CONTAINED_BY) === Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            throw new Error(\"Failed to sanitize html because the element is clobbered: \" + node.outerHTML);\n        }\n        return nextNode;\n    };\n    return SanitizingHtmlSerializer;\n}());\n// Regular Expressions for parsing tags and attributes\nvar SURROGATE_PAIR_REGEXP = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g;\n// ! to ~ is the ASCII range.\nvar NON_ALPHANUMERIC_REGEXP = /([^\\#-~ |!])/g;\n/**\n * Escapes all potentially dangerous characters, so that the\n * resulting string can be safely inserted into attribute or\n * element text.\n * @param value\n */\nfunction encodeEntities(value) {\n    return value.replace(/&/g, '&amp;')\n        .replace(SURROGATE_PAIR_REGEXP, function (match) {\n        var hi = match.charCodeAt(0);\n        var low = match.charCodeAt(1);\n        return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';\n    })\n        .replace(NON_ALPHANUMERIC_REGEXP, function (match) { return '&#' + match.charCodeAt(0) + ';'; })\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;');\n}\nvar inertBodyHelper;\n/**\n * Sanitizes the given unsafe, untrusted HTML fragment, and returns HTML text that is safe to add to\n * the DOM in a browser environment.\n */\nfunction _sanitizeHtml(defaultDoc, unsafeHtmlInput) {\n    var inertBodyElement = null;\n    try {\n        inertBodyHelper = inertBodyHelper || new InertBodyHelper(defaultDoc);\n        // Make sure unsafeHtml is actually a string (TypeScript types are not enforced at runtime).\n        var unsafeHtml = unsafeHtmlInput ? String(unsafeHtmlInput) : '';\n        inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);\n        // mXSS protection. Repeatedly parse the document to make sure it stabilizes, so that a browser\n        // trying to auto-correct incorrect HTML cannot cause formerly inert HTML to become dangerous.\n        var mXSSAttempts = 5;\n        var parsedHtml = unsafeHtml;\n        do {\n            if (mXSSAttempts === 0) {\n                throw new Error('Failed to sanitize html because the input is unstable');\n            }\n            mXSSAttempts--;\n            unsafeHtml = parsedHtml;\n            parsedHtml = inertBodyElement.innerHTML;\n            inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);\n        } while (unsafeHtml !== parsedHtml);\n        var sanitizer = new SanitizingHtmlSerializer();\n        var safeHtml = sanitizer.sanitizeChildren(getTemplateContent(inertBodyElement) || inertBodyElement);\n        if (isDevMode() && sanitizer.sanitizedSomething) {\n            console.warn('WARNING: sanitizing HTML stripped some content (see http://g.co/ng/security#xss).');\n        }\n        return safeHtml;\n    }\n    finally {\n        // In case anything goes wrong, clear out inertElement to reset the entire DOM structure.\n        if (inertBodyElement) {\n            var parent_1 = getTemplateContent(inertBodyElement) || inertBodyElement;\n            while (parent_1.firstChild) {\n                parent_1.removeChild(parent_1.firstChild);\n            }\n        }\n    }\n}\nfunction getTemplateContent(el) {\n    return 'content' in el /** Microsoft/TypeScript#21517 */ && isTemplateElement(el) ?\n        el.content :\n        null;\n}\nfunction isTemplateElement(el) {\n    return el.nodeType === Node.ELEMENT_NODE && el.nodeName === 'TEMPLATE';\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 * Regular expression for safe style values.\n *\n * Quotes (\" and ') are allowed, but a check must be done elsewhere to ensure they're balanced.\n *\n * ',' allows multiple values to be assigned to the same property (e.g. background-attachment or\n * font-family) and hence could allow multiple values to get injected, but that should pose no risk\n * of XSS.\n *\n * The function expression checks only for XSS safety, not for CSS validity.\n *\n * This regular expression was taken from the Closure sanitization library, and augmented for\n * transformation values.\n */\nvar VALUES = '[-,.\"\\'%_!# a-zA-Z0-9]+';\nvar TRANSFORMATION_FNS = '(?:matrix|translate|scale|rotate|skew|perspective)(?:X|Y|3d)?';\nvar COLOR_FNS = '(?:rgb|hsl)a?';\nvar GRADIENTS = '(?:repeating-)?(?:linear|radial)-gradient';\nvar CSS3_FNS = '(?:calc|attr)';\nvar FN_ARGS = '\\\\([-0-9.%, #a-zA-Z]+\\\\)';\nvar SAFE_STYLE_VALUE = new RegExp(\"^(\" + VALUES + \"|\" +\n    (\"(?:\" + TRANSFORMATION_FNS + \"|\" + COLOR_FNS + \"|\" + GRADIENTS + \"|\" + CSS3_FNS + \")\") +\n    (FN_ARGS + \")$\"), 'g');\n/**\n * Matches a `url(...)` value with an arbitrary argument as long as it does\n * not contain parentheses.\n *\n * The URL value still needs to be sanitized separately.\n *\n * `url(...)` values are a very common use case, e.g. for `background-image`. With carefully crafted\n * CSS style rules, it is possible to construct an information leak with `url` values in CSS, e.g.\n * by observing whether scroll bars are displayed, or character ranges used by a font face\n * definition.\n *\n * Angular only allows binding CSS values (as opposed to entire CSS rules), so it is unlikely that\n * binding a URL value without further cooperation from the page will cause an information leak, and\n * if so, it is just a leak, not a full blown XSS vulnerability.\n *\n * Given the common use case, low likelihood of attack vector, and low impact of an attack, this\n * code is permissive and allows URLs that sanitize otherwise.\n */\nvar URL_RE = /^url\\(([^)]+)\\)$/;\n/**\n * Checks that quotes (\" and ') are properly balanced inside a string. Assumes\n * that neither escape (\\) nor any other character that could result in\n * breaking out of a string parsing context are allowed;\n * see http://www.w3.org/TR/css3-syntax/#string-token-diagram.\n *\n * This code was taken from the Closure sanitization library.\n */\nfunction hasBalancedQuotes(value) {\n    var outsideSingle = true;\n    var outsideDouble = true;\n    for (var i = 0; i < value.length; i++) {\n        var c = value.charAt(i);\n        if (c === '\\'' && outsideDouble) {\n            outsideSingle = !outsideSingle;\n        }\n        else if (c === '\"' && outsideSingle) {\n            outsideDouble = !outsideDouble;\n        }\n    }\n    return outsideSingle && outsideDouble;\n}\n/**\n * Sanitizes the given untrusted CSS style property value (i.e. not an entire object, just a single\n * value) and returns a value that is safe to use in a browser environment.\n */\nfunction _sanitizeStyle(value) {\n    value = String(value).trim(); // Make sure it's actually a string.\n    if (!value)\n        return '';\n    // Single url(...) values are supported, but only for URLs that sanitize cleanly. See above for\n    // reasoning behind this.\n    var urlMatch = value.match(URL_RE);\n    if ((urlMatch && _sanitizeUrl(urlMatch[1]) === urlMatch[1]) ||\n        value.match(SAFE_STYLE_VALUE) && hasBalancedQuotes(value)) {\n        return value; // Safe style values.\n    }\n    if (isDevMode()) {\n        console.warn(\"WARNING: sanitizing unsafe style value \" + value + \" (see http://g.co/ng/security#xss).\");\n    }\n    return 'unsafe';\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property\n * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly\n * handled.\n *\n * See DomSanitizer for more details on security in Angular applications.\n *\n *\n */\n\n(function (SecurityContext) {\n    SecurityContext[SecurityContext[\"NONE\"] = 0] = \"NONE\";\n    SecurityContext[SecurityContext[\"HTML\"] = 1] = \"HTML\";\n    SecurityContext[SecurityContext[\"STYLE\"] = 2] = \"STYLE\";\n    SecurityContext[SecurityContext[\"SCRIPT\"] = 3] = \"SCRIPT\";\n    SecurityContext[SecurityContext[\"URL\"] = 4] = \"URL\";\n    SecurityContext[SecurityContext[\"RESOURCE_URL\"] = 5] = \"RESOURCE_URL\";\n})(exports.SecurityContext || (exports.SecurityContext = {}));\n/**\n * Sanitizer is used by the views to sanitize potentially dangerous values.\n *\n *\n */\nvar Sanitizer = /** @class */ (function () {\n    function Sanitizer() {\n    }\n    return Sanitizer;\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// Called before each cycle of a view's check to detect whether this is in the\n// initState for which we need to call ngOnInit, ngAfterContentInit or ngAfterViewInit\n// lifecycle methods. Returns true if this check cycle should call lifecycle\n// methods.\nfunction shiftInitState(view, priorInitState, newInitState) {\n    // Only update the InitState if we are currently in the prior state.\n    // For example, only move into CallingInit if we are in BeforeInit. Only\n    // move into CallingContentInit if we are in CallingInit. Normally this will\n    // always be true because of how checkCycle is called in checkAndUpdateView.\n    // However, if checkAndUpdateView is called recursively or if an exception is\n    // thrown while checkAndUpdateView is running, checkAndUpdateView starts over\n    // from the beginning. This ensures the state is monotonically increasing,\n    // terminating in the AfterInit state, which ensures the Init methods are called\n    // at least once and only once.\n    var state = view.state;\n    var initState = state & 1792;\n    if (initState === priorInitState) {\n        view.state = (state & ~1792 /* InitState_Mask */) | newInitState;\n        view.initIndex = -1;\n        return true;\n    }\n    return initState === newInitState;\n}\n// Returns true if the lifecycle init method should be called for the node with\n// the given init index.\nfunction shouldCallLifecycleInitHook(view, initState, index) {\n    if ((view.state & 1792 /* InitState_Mask */) === initState && view.initIndex <= index) {\n        view.initIndex = index + 1;\n        return true;\n    }\n    return false;\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asTextData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asElementData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asProviderData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asPureExpressionData(view, index) {\n    return view.nodes[index];\n}\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nfunction asQueryList(view, index) {\n    return view.nodes[index];\n}\nvar DebugContext = /** @class */ (function () {\n    function DebugContext() {\n    }\n    return DebugContext;\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 */\nvar Services = {\n    setCurrentNode: undefined,\n    createRootView: undefined,\n    createEmbeddedView: undefined,\n    createComponentView: undefined,\n    createNgModuleRef: undefined,\n    overrideProvider: undefined,\n    overrideComponentView: undefined,\n    clearOverrides: 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/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction expressionChangedAfterItHasBeenCheckedError(context, oldValue, currValue, isFirstCheck) {\n    var msg = \"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}\nfunction viewWrappedDebugError(err, context) {\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}\nfunction viewDebugError(msg, context) {\n    var err = new Error(msg);\n    _addDebugContext(err, context);\n    return err;\n}\nfunction _addDebugContext(err, context) {\n    err[ERROR_DEBUG_CONTEXT] = context;\n    err[ERROR_LOGGER] = context.logError.bind(context);\n}\nfunction isViewDebugError(err) {\n    return !!getDebugContext(err);\n}\nfunction viewDestroyedError(action) {\n    return new Error(\"ViewDestroyedError: Attempt to use a destroyed view: \" + action);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NOOP = function () { };\nvar _tokenKeyCache = new Map();\nfunction tokenKey(token) {\n    var key = _tokenKeyCache.get(token);\n    if (!key) {\n        key = stringify(token) + '_' + _tokenKeyCache.size;\n        _tokenKeyCache.set(token, key);\n    }\n    return key;\n}\nfunction unwrapValue(view, nodeIdx, bindingIdx, value) {\n    if (WrappedValue.isWrapped(value)) {\n        value = WrappedValue.unwrap(value);\n        var globalBindingIdx = view.def.nodes[nodeIdx].bindingIndex + bindingIdx;\n        var oldValue = WrappedValue.unwrap(view.oldValues[globalBindingIdx]);\n        view.oldValues[globalBindingIdx] = new WrappedValue(oldValue);\n    }\n    return value;\n}\nvar UNDEFINED_RENDERER_TYPE_ID = '$$undefined';\nvar EMPTY_RENDERER_TYPE_ID = '$$empty';\n// Attention: this function is called as top level function.\n// Putting any logic in here will destroy closure tree shaking!\nfunction createRendererType2(values) {\n    return {\n        id: UNDEFINED_RENDERER_TYPE_ID,\n        styles: values.styles,\n        encapsulation: values.encapsulation,\n        data: values.data\n    };\n}\nvar _renderCompCount = 0;\nfunction resolveRendererType2(type) {\n    if (type && type.id === UNDEFINED_RENDERER_TYPE_ID) {\n        // first time we see this RendererType2. Initialize it...\n        var isFilled = ((type.encapsulation != null && type.encapsulation !== exports.ViewEncapsulation.None) ||\n            type.styles.length || Object.keys(type.data).length);\n        if (isFilled) {\n            type.id = \"c\" + _renderCompCount++;\n        }\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}\nfunction checkBinding(view, def, bindingIdx, value) {\n    var oldValues = view.oldValues;\n    if ((view.state & 2 /* FirstCheck */) ||\n        !looseIdentical(oldValues[def.bindingIndex + bindingIdx], value)) {\n        return true;\n    }\n    return false;\n}\nfunction checkAndUpdateBinding(view, def, bindingIdx, value) {\n    if (checkBinding(view, def, bindingIdx, value)) {\n        view.oldValues[def.bindingIndex + bindingIdx] = value;\n        return true;\n    }\n    return false;\n}\nfunction checkBindingNoChanges(view, def, bindingIdx, value) {\n    var oldValue = view.oldValues[def.bindingIndex + bindingIdx];\n    if ((view.state & 1 /* BeforeFirstCheck */) || !devModeEqual(oldValue, value)) {\n        var bindingName = def.bindings[bindingIdx].name;\n        throw expressionChangedAfterItHasBeenCheckedError(Services.createDebugContext(view, def.nodeIndex), bindingName + \": \" + oldValue, bindingName + \": \" + value, (view.state & 1 /* BeforeFirstCheck */) !== 0);\n    }\n}\nfunction markParentViewsForCheck(view) {\n    var currView = view;\n    while (currView) {\n        if (currView.def.flags & 2 /* OnPush */) {\n            currView.state |= 8 /* ChecksEnabled */;\n        }\n        currView = currView.viewContainerParent || currView.parent;\n    }\n}\nfunction markParentViewsForCheckProjectedViews(view, endView) {\n    var currView = view;\n    while (currView && currView !== endView) {\n        currView.state |= 64 /* CheckProjectedViews */;\n        currView = currView.viewContainerParent || currView.parent;\n    }\n}\nfunction dispatchEvent(view, nodeIndex, eventName, event) {\n    try {\n        var nodeDef = view.def.nodes[nodeIndex];\n        var startView = nodeDef.flags & 33554432 /* ComponentView */ ?\n            asElementData(view, nodeIndex).componentView :\n            view;\n        markParentViewsForCheck(startView);\n        return Services.handleEvent(view, nodeIndex, eventName, event);\n    }\n    catch (e) {\n        // Attention: Don't rethrow, as it would cancel Observable subscriptions!\n        view.root.errorHandler.handleError(e);\n    }\n}\nfunction declaredViewContainer(view) {\n    if (view.parent) {\n        var parentView = view.parent;\n        return asElementData(parentView, view.parentNodeDef.nodeIndex);\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 */\nfunction viewParentEl(view) {\n    var parentView = view.parent;\n    if (parentView) {\n        return view.parentNodeDef.parent;\n    }\n    else {\n        return null;\n    }\n}\nfunction renderNode(view, def) {\n    switch (def.flags & 201347067 /* Types */) {\n        case 1 /* TypeElement */:\n            return asElementData(view, def.nodeIndex).renderElement;\n        case 2 /* TypeText */:\n            return asTextData(view, def.nodeIndex).renderText;\n    }\n}\nfunction elementEventFullName(target, name) {\n    return target ? target + \":\" + name : name;\n}\nfunction isComponentView(view) {\n    return !!view.parent && !!(view.parentNodeDef.flags & 32768 /* Component */);\n}\nfunction isEmbeddedView(view) {\n    return !!view.parent && !(view.parentNodeDef.flags & 32768 /* Component */);\n}\nfunction filterQueryId(queryId) {\n    return 1 << (queryId % 32);\n}\nfunction splitMatchedQueriesDsl(matchedQueriesDsl) {\n    var matchedQueries = {};\n    var matchedQueryIds = 0;\n    var references = {};\n    if (matchedQueriesDsl) {\n        matchedQueriesDsl.forEach(function (_a) {\n            var _b = __read(_a, 2), queryId = _b[0], valueType = _b[1];\n            if (typeof queryId === 'number') {\n                matchedQueries[queryId] = valueType;\n                matchedQueryIds |= filterQueryId(queryId);\n            }\n            else {\n                references[queryId] = valueType;\n            }\n        });\n    }\n    return { matchedQueries: matchedQueries, references: references, matchedQueryIds: matchedQueryIds };\n}\nfunction splitDepsDsl(deps, sourceName) {\n    return deps.map(function (value) {\n        var token;\n        var flags;\n        if (Array.isArray(value)) {\n            _a = __read(value, 2), flags = _a[0], token = _a[1];\n        }\n        else {\n            flags = 0 /* None */;\n            token = value;\n        }\n        if (token && (typeof token === 'function' || typeof token === 'object') && sourceName) {\n            Object.defineProperty(token, SOURCE, { value: sourceName, configurable: true });\n        }\n        return { flags: flags, token: token, tokenKey: tokenKey(token) };\n        var _a;\n    });\n}\nfunction getParentRenderElement(view, renderHost, def) {\n    var renderParent = def.renderParent;\n    if (renderParent) {\n        if ((renderParent.flags & 1 /* TypeElement */) === 0 ||\n            (renderParent.flags & 33554432 /* ComponentView */) === 0 ||\n            (renderParent.element.componentRendererType &&\n                renderParent.element.componentRendererType.encapsulation ===\n                    exports.ViewEncapsulation.Native)) {\n            // only children of non components, or children of components with native encapsulation should\n            // be attached.\n            return asElementData(view, def.renderParent.nodeIndex).renderElement;\n        }\n    }\n    else {\n        return renderHost;\n    }\n}\nvar DEFINITION_CACHE = new WeakMap();\nfunction resolveDefinition(factory) {\n    var value = DEFINITION_CACHE.get(factory);\n    if (!value) {\n        value = factory(function () { return NOOP; });\n        value.factory = factory;\n        DEFINITION_CACHE.set(factory, value);\n    }\n    return value;\n}\nfunction rootRenderNodes(view) {\n    var renderNodes = [];\n    visitRootRenderNodes(view, 0 /* Collect */, undefined, undefined, renderNodes);\n    return renderNodes;\n}\nfunction visitRootRenderNodes(view, action, parentNode, nextSibling, target) {\n    // We need to re-compute the parent node in case the nodes have been moved around manually\n    if (action === 3 /* RemoveChild */) {\n        parentNode = view.renderer.parentNode(renderNode(view, view.def.lastRenderRootNode));\n    }\n    visitSiblingRenderNodes(view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);\n}\nfunction visitSiblingRenderNodes(view, action, startIndex, endIndex, parentNode, nextSibling, target) {\n    for (var i = startIndex; i <= endIndex; i++) {\n        var nodeDef = view.def.nodes[i];\n        if (nodeDef.flags & (1 /* TypeElement */ | 2 /* TypeText */ | 8 /* TypeNgContent */)) {\n            visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target);\n        }\n        // jump to next sibling\n        i += nodeDef.childCount;\n    }\n}\nfunction visitProjectedRenderNodes(view, ngContentIndex, action, parentNode, nextSibling, target) {\n    var compView = view;\n    while (compView && !isComponentView(compView)) {\n        compView = compView.parent;\n    }\n    var hostView = compView.parent;\n    var hostElDef = viewParentEl(compView);\n    var startIndex = hostElDef.nodeIndex + 1;\n    var endIndex = hostElDef.nodeIndex + hostElDef.childCount;\n    for (var i = startIndex; i <= endIndex; i++) {\n        var nodeDef = hostView.def.nodes[i];\n        if (nodeDef.ngContentIndex === ngContentIndex) {\n            visitRenderNode(hostView, nodeDef, action, parentNode, nextSibling, target);\n        }\n        // jump to next sibling\n        i += nodeDef.childCount;\n    }\n    if (!hostView.parent) {\n        // a root view\n        var projectedNodes = view.root.projectableNodes[ngContentIndex];\n        if (projectedNodes) {\n            for (var i = 0; i < projectedNodes.length; i++) {\n                execRenderNodeAction(view, projectedNodes[i], action, parentNode, nextSibling, target);\n            }\n        }\n    }\n}\nfunction visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target) {\n    if (nodeDef.flags & 8 /* TypeNgContent */) {\n        visitProjectedRenderNodes(view, nodeDef.ngContent.index, action, parentNode, nextSibling, target);\n    }\n    else {\n        var rn = renderNode(view, nodeDef);\n        if (action === 3 /* RemoveChild */ && (nodeDef.flags & 33554432 /* ComponentView */) &&\n            (nodeDef.bindingFlags & 48 /* CatSyntheticProperty */)) {\n            // Note: we might need to do both actions.\n            if (nodeDef.bindingFlags & (16 /* SyntheticProperty */)) {\n                execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n            }\n            if (nodeDef.bindingFlags & (32 /* SyntheticHostProperty */)) {\n                var compView = asElementData(view, nodeDef.nodeIndex).componentView;\n                execRenderNodeAction(compView, rn, action, parentNode, nextSibling, target);\n            }\n        }\n        else {\n            execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n        }\n        if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n            var embeddedViews = asElementData(view, nodeDef.nodeIndex).viewContainer._embeddedViews;\n            for (var k = 0; k < embeddedViews.length; k++) {\n                visitRootRenderNodes(embeddedViews[k], action, parentNode, nextSibling, target);\n            }\n        }\n        if (nodeDef.flags & 1 /* TypeElement */ && !nodeDef.element.name) {\n            visitSiblingRenderNodes(view, action, nodeDef.nodeIndex + 1, nodeDef.nodeIndex + nodeDef.childCount, parentNode, nextSibling, target);\n        }\n    }\n}\nfunction execRenderNodeAction(view, renderNode, action, parentNode, nextSibling, target) {\n    var renderer = view.renderer;\n    switch (action) {\n        case 1 /* AppendChild */:\n            renderer.appendChild(parentNode, renderNode);\n            break;\n        case 2 /* InsertBefore */:\n            renderer.insertBefore(parentNode, renderNode, nextSibling);\n            break;\n        case 3 /* RemoveChild */:\n            renderer.removeChild(parentNode, renderNode);\n            break;\n        case 0 /* Collect */:\n            target.push(renderNode);\n            break;\n    }\n}\nvar NS_PREFIX_RE = /^:([^:]+):(.+)$/;\nfunction splitNamespace(name) {\n    if (name[0] === ':') {\n        var match = name.match(NS_PREFIX_RE);\n        return [match[1], match[2]];\n    }\n    return ['', name];\n}\nfunction calcBindingFlags(bindings) {\n    var flags = 0;\n    for (var i = 0; i < bindings.length; i++) {\n        flags |= bindings[i].flags;\n    }\n    return flags;\n}\nfunction interpolate(valueCount, constAndInterp) {\n    var result = '';\n    for (var 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}\nfunction inlineInterpolate(valueCount, c0, a1, c1, a2, c2, a3, c3, a4, c4, a5, c5, a6, c6, a7, c7, a8, c8, a9, c9) {\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}\nfunction _toStringWithNull(v) {\n    return v != null ? v.toString() : '';\n}\nvar EMPTY_ARRAY$2 = [];\nvar EMPTY_MAP = {};\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction anchorDef(flags, matchedQueriesDsl, ngContentIndex, childCount, handleEvent, templateFactory) {\n    flags |= 1 /* TypeElement */;\n    var _a = splitMatchedQueriesDsl(matchedQueriesDsl), matchedQueries = _a.matchedQueries, references = _a.references, matchedQueryIds = _a.matchedQueryIds;\n    var template = templateFactory ? resolveDefinition(templateFactory) : null;\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        flags: flags,\n        checkIndex: -1,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0, matchedQueries: matchedQueries, matchedQueryIds: matchedQueryIds, references: references, ngContentIndex: ngContentIndex, childCount: childCount,\n        bindings: [],\n        bindingFlags: 0,\n        outputs: [],\n        element: {\n            ns: null,\n            name: null,\n            attrs: null, template: 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}\nfunction elementDef(checkIndex, flags, matchedQueriesDsl, ngContentIndex, childCount, namespaceAndName, fixedAttrs, bindings, outputs, handleEvent, componentView, componentRendererType) {\n    if (fixedAttrs === void 0) { fixedAttrs = []; }\n    if (!handleEvent) {\n        handleEvent = NOOP;\n    }\n    var _a = splitMatchedQueriesDsl(matchedQueriesDsl), matchedQueries = _a.matchedQueries, references = _a.references, matchedQueryIds = _a.matchedQueryIds;\n    var ns = null;\n    var name = null;\n    if (namespaceAndName) {\n        _b = __read(splitNamespace(namespaceAndName), 2), ns = _b[0], name = _b[1];\n    }\n    bindings = bindings || [];\n    var bindingDefs = new Array(bindings.length);\n    for (var i = 0; i < bindings.length; i++) {\n        var _c = __read(bindings[i], 3), bindingFlags = _c[0], namespaceAndName_1 = _c[1], suffixOrSecurityContext = _c[2];\n        var _d = __read(splitNamespace(namespaceAndName_1), 2), ns_1 = _d[0], name_1 = _d[1];\n        var securityContext = undefined;\n        var suffix = undefined;\n        switch (bindingFlags & 15 /* Types */) {\n            case 4 /* TypeElementStyle */:\n                suffix = suffixOrSecurityContext;\n                break;\n            case 1 /* TypeElementAttribute */:\n            case 8 /* TypeProperty */:\n                securityContext = suffixOrSecurityContext;\n                break;\n        }\n        bindingDefs[i] =\n            { flags: bindingFlags, ns: ns_1, name: name_1, nonMinifiedName: name_1, securityContext: securityContext, suffix: suffix };\n    }\n    outputs = outputs || [];\n    var outputDefs = new Array(outputs.length);\n    for (var i = 0; i < outputs.length; i++) {\n        var _e = __read(outputs[i], 2), target = _e[0], eventName = _e[1];\n        outputDefs[i] = {\n            type: 0 /* ElementOutput */,\n            target: target, eventName: eventName,\n            propName: null\n        };\n    }\n    fixedAttrs = fixedAttrs || [];\n    var attrs = fixedAttrs.map(function (_a) {\n        var _b = __read(_a, 2), namespaceAndName = _b[0], value = _b[1];\n        var _c = __read(splitNamespace(namespaceAndName), 2), ns = _c[0], name = _c[1];\n        return [ns, name, value];\n    });\n    componentRendererType = resolveRendererType2(componentRendererType);\n    if (componentView) {\n        flags |= 33554432 /* ComponentView */;\n    }\n    flags |= 1 /* TypeElement */;\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: flags,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0, matchedQueries: matchedQueries, matchedQueryIds: matchedQueryIds, references: references, ngContentIndex: ngContentIndex, childCount: childCount,\n        bindings: bindingDefs,\n        bindingFlags: calcBindingFlags(bindingDefs),\n        outputs: outputDefs,\n        element: {\n            ns: ns,\n            name: name,\n            attrs: 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    var _b;\n}\nfunction createElement(view, renderHost, def) {\n    var elDef = def.element;\n    var rootSelectorOrNode = view.root.selectorOrNode;\n    var renderer = view.renderer;\n    var el;\n    if (view.parent || !rootSelectorOrNode) {\n        if (elDef.name) {\n            el = renderer.createElement(elDef.name, elDef.ns);\n        }\n        else {\n            el = renderer.createComment('');\n        }\n        var parentEl = getParentRenderElement(view, renderHost, def);\n        if (parentEl) {\n            renderer.appendChild(parentEl, el);\n        }\n    }\n    else {\n        el = renderer.selectRootElement(rootSelectorOrNode);\n    }\n    if (elDef.attrs) {\n        for (var i = 0; i < elDef.attrs.length; i++) {\n            var _a = __read(elDef.attrs[i], 3), ns = _a[0], name_2 = _a[1], value = _a[2];\n            renderer.setAttribute(el, name_2, value, ns);\n        }\n    }\n    return el;\n}\nfunction listenToElementOutputs(view, compView, def, el) {\n    for (var i = 0; i < def.outputs.length; i++) {\n        var output = def.outputs[i];\n        var handleEventClosure = renderEventHandlerClosure(view, def.nodeIndex, elementEventFullName(output.target, output.eventName));\n        var listenTarget = output.target;\n        var listenerView = view;\n        if (output.target === 'component') {\n            listenTarget = null;\n            listenerView = compView;\n        }\n        var disposable = listenerView.renderer.listen(listenTarget || el, output.eventName, handleEventClosure);\n        view.disposables[def.outputIndex + i] = disposable;\n    }\n}\nfunction renderEventHandlerClosure(view, index, eventName) {\n    return function (event) { return dispatchEvent(view, index, eventName, event); };\n}\nfunction checkAndUpdateElementInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var bindLen = def.bindings.length;\n    var changed = false;\n    if (bindLen > 0 && checkAndUpdateElementValue(view, def, 0, v0))\n        changed = true;\n    if (bindLen > 1 && checkAndUpdateElementValue(view, def, 1, v1))\n        changed = true;\n    if (bindLen > 2 && checkAndUpdateElementValue(view, def, 2, v2))\n        changed = true;\n    if (bindLen > 3 && checkAndUpdateElementValue(view, def, 3, v3))\n        changed = true;\n    if (bindLen > 4 && checkAndUpdateElementValue(view, def, 4, v4))\n        changed = true;\n    if (bindLen > 5 && checkAndUpdateElementValue(view, def, 5, v5))\n        changed = true;\n    if (bindLen > 6 && checkAndUpdateElementValue(view, def, 6, v6))\n        changed = true;\n    if (bindLen > 7 && checkAndUpdateElementValue(view, def, 7, v7))\n        changed = true;\n    if (bindLen > 8 && checkAndUpdateElementValue(view, def, 8, v8))\n        changed = true;\n    if (bindLen > 9 && checkAndUpdateElementValue(view, def, 9, v9))\n        changed = true;\n    return changed;\n}\nfunction checkAndUpdateElementDynamic(view, def, values) {\n    var changed = false;\n    for (var i = 0; i < values.length; i++) {\n        if (checkAndUpdateElementValue(view, def, i, values[i]))\n            changed = true;\n    }\n    return changed;\n}\nfunction checkAndUpdateElementValue(view, def, bindingIdx, value) {\n    if (!checkAndUpdateBinding(view, def, bindingIdx, value)) {\n        return false;\n    }\n    var binding = def.bindings[bindingIdx];\n    var elData = asElementData(view, def.nodeIndex);\n    var renderNode$$1 = elData.renderElement;\n    var name = binding.name;\n    switch (binding.flags & 15 /* Types */) {\n        case 1 /* TypeElementAttribute */:\n            setElementAttribute(view, binding, renderNode$$1, binding.ns, name, value);\n            break;\n        case 2 /* TypeElementClass */:\n            setElementClass(view, renderNode$$1, name, value);\n            break;\n        case 4 /* TypeElementStyle */:\n            setElementStyle(view, binding, renderNode$$1, name, value);\n            break;\n        case 8 /* TypeProperty */:\n            var bindView = (def.flags & 33554432 /* ComponentView */ &&\n                binding.flags & 32 /* SyntheticHostProperty */) ?\n                elData.componentView :\n                view;\n            setElementProperty(bindView, binding, renderNode$$1, name, value);\n            break;\n    }\n    return true;\n}\nfunction setElementAttribute(view, binding, renderNode$$1, ns, name, value) {\n    var securityContext = binding.securityContext;\n    var renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;\n    renderValue = renderValue != null ? renderValue.toString() : null;\n    var renderer = view.renderer;\n    if (value != null) {\n        renderer.setAttribute(renderNode$$1, name, renderValue, ns);\n    }\n    else {\n        renderer.removeAttribute(renderNode$$1, name, ns);\n    }\n}\nfunction setElementClass(view, renderNode$$1, name, value) {\n    var renderer = view.renderer;\n    if (value) {\n        renderer.addClass(renderNode$$1, name);\n    }\n    else {\n        renderer.removeClass(renderNode$$1, name);\n    }\n}\nfunction setElementStyle(view, binding, renderNode$$1, name, value) {\n    var renderValue = view.root.sanitizer.sanitize(exports.SecurityContext.STYLE, value);\n    if (renderValue != null) {\n        renderValue = renderValue.toString();\n        var unit = binding.suffix;\n        if (unit != null) {\n            renderValue = renderValue + unit;\n        }\n    }\n    else {\n        renderValue = null;\n    }\n    var renderer = view.renderer;\n    if (renderValue != null) {\n        renderer.setStyle(renderNode$$1, name, renderValue);\n    }\n    else {\n        renderer.removeStyle(renderNode$$1, name);\n    }\n}\nfunction setElementProperty(view, binding, renderNode$$1, name, value) {\n    var securityContext = binding.securityContext;\n    var renderValue = securityContext ? view.root.sanitizer.sanitize(securityContext, value) : value;\n    view.renderer.setProperty(renderNode$$1, name, renderValue);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar UNDEFINED_VALUE = new Object();\nvar InjectorRefTokenKey$1 = tokenKey(Injector);\nvar INJECTORRefTokenKey$1 = tokenKey(INJECTOR);\nvar NgModuleRefTokenKey = tokenKey(NgModuleRef);\nfunction moduleProvideDef(flags, token, value, deps) {\n    // Need to resolve forwardRefs as e.g. for `useValue` we\n    // lowered the expression and then stopped evaluating it,\n    // i.e. also didn't unwrap it.\n    value = resolveForwardRef(value);\n    var depDefs = splitDepsDsl(deps, stringify(token));\n    return {\n        // will bet set by the module definition\n        index: -1,\n        deps: depDefs, flags: flags, token: token, value: value\n    };\n}\nfunction moduleDef(providers) {\n    var providersByKey = {};\n    var modules = [];\n    var isRoot = false;\n    for (var i = 0; i < providers.length; i++) {\n        var provider = providers[i];\n        if (provider.token === APP_ROOT) {\n            isRoot = true;\n        }\n        if (provider.flags & 1073741824 /* TypeNgModule */) {\n            modules.push(provider.token);\n        }\n        provider.index = i;\n        providersByKey[tokenKey(provider.token)] = provider;\n    }\n    return {\n        // Will be filled later...\n        factory: null,\n        providersByKey: providersByKey,\n        providers: providers,\n        modules: modules,\n        isRoot: isRoot,\n    };\n}\nfunction initNgModule(data) {\n    var def = data._def;\n    var providers = data._providers = new Array(def.providers.length);\n    for (var i = 0; i < def.providers.length; i++) {\n        var provDef = def.providers[i];\n        if (!(provDef.flags & 4096 /* LazyProvider */)) {\n            // Make sure the provider has not been already initialized outside this loop.\n            if (providers[i] === undefined) {\n                providers[i] = _createProviderInstance$1(data, provDef);\n            }\n        }\n    }\n}\nfunction resolveNgModuleDep(data, depDef, notFoundValue) {\n    if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n    var former = setCurrentInjector(data);\n    try {\n        if (depDef.flags & 8 /* Value */) {\n            return depDef.token;\n        }\n        if (depDef.flags & 2 /* Optional */) {\n            notFoundValue = null;\n        }\n        if (depDef.flags & 1 /* SkipSelf */) {\n            return data._parent.get(depDef.token, notFoundValue);\n        }\n        var tokenKey_1 = depDef.tokenKey;\n        switch (tokenKey_1) {\n            case InjectorRefTokenKey$1:\n            case INJECTORRefTokenKey$1:\n            case NgModuleRefTokenKey:\n                return data;\n        }\n        var providerDef = data._def.providersByKey[tokenKey_1];\n        if (providerDef) {\n            var providerInstance = data._providers[providerDef.index];\n            if (providerInstance === undefined) {\n                providerInstance = data._providers[providerDef.index] =\n                    _createProviderInstance$1(data, providerDef);\n            }\n            return providerInstance === UNDEFINED_VALUE ? undefined : providerInstance;\n        }\n        else if (depDef.token.ngInjectableDef && targetsModule(data, depDef.token.ngInjectableDef)) {\n            var injectableDef = depDef.token.ngInjectableDef;\n            var index = data._providers.length;\n            data._def.providersByKey[depDef.tokenKey] = {\n                flags: 1024 /* TypeFactoryProvider */ | 4096 /* LazyProvider */,\n                value: injectableDef.factory,\n                deps: [], index: index,\n                token: depDef.token,\n            };\n            data._providers[index] = UNDEFINED_VALUE;\n            return (data._providers[index] =\n                _createProviderInstance$1(data, data._def.providersByKey[depDef.tokenKey]));\n        }\n        else if (depDef.flags & 4 /* Self */) {\n            return notFoundValue;\n        }\n        return data._parent.get(depDef.token, notFoundValue);\n    }\n    finally {\n        setCurrentInjector(former);\n    }\n}\nfunction moduleTransitivelyPresent(ngModule, scope) {\n    return ngModule._def.modules.indexOf(scope) > -1;\n}\nfunction targetsModule(ngModule, def) {\n    return def.providedIn != null && (moduleTransitivelyPresent(ngModule, def.providedIn) ||\n        def.providedIn === 'root' && ngModule._def.isRoot);\n}\nfunction _createProviderInstance$1(ngModule, providerDef) {\n    var injectable;\n    switch (providerDef.flags & 201347067 /* Types */) {\n        case 512 /* TypeClassProvider */:\n            injectable = _createClass(ngModule, providerDef.value, providerDef.deps);\n            break;\n        case 1024 /* TypeFactoryProvider */:\n            injectable = _callFactory(ngModule, providerDef.value, providerDef.deps);\n            break;\n        case 2048 /* TypeUseExistingProvider */:\n            injectable = resolveNgModuleDep(ngModule, providerDef.deps[0]);\n            break;\n        case 256 /* TypeValueProvider */:\n            injectable = providerDef.value;\n            break;\n    }\n    // The read of `ngOnDestroy` here is slightly expensive as it's megamorphic, so it should be\n    // avoided if possible. The sequence of checks here determines whether ngOnDestroy needs to be\n    // checked. It might not if the `injectable` isn't an object or if NodeFlags.OnDestroy is already\n    // set (ngOnDestroy was detected statically).\n    if (injectable !== UNDEFINED_VALUE && injectable != null && typeof injectable === 'object' &&\n        !(providerDef.flags & 131072 /* OnDestroy */) && typeof injectable.ngOnDestroy === 'function') {\n        providerDef.flags |= 131072 /* OnDestroy */;\n    }\n    return injectable === undefined ? UNDEFINED_VALUE : injectable;\n}\nfunction _createClass(ngModule, ctor, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return new ctor();\n        case 1:\n            return new ctor(resolveNgModuleDep(ngModule, deps[0]));\n        case 2:\n            return new ctor(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));\n        case 3:\n            return new ctor(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]), resolveNgModuleDep(ngModule, deps[2]));\n        default:\n            var depValues = new Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveNgModuleDep(ngModule, deps[i]);\n            }\n            return new (ctor.bind.apply(ctor, __spread([void 0], depValues)))();\n    }\n}\nfunction _callFactory(ngModule, factory, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return factory();\n        case 1:\n            return factory(resolveNgModuleDep(ngModule, deps[0]));\n        case 2:\n            return factory(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]));\n        case 3:\n            return factory(resolveNgModuleDep(ngModule, deps[0]), resolveNgModuleDep(ngModule, deps[1]), resolveNgModuleDep(ngModule, deps[2]));\n        default:\n            var depValues = Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveNgModuleDep(ngModule, deps[i]);\n            }\n            return factory.apply(void 0, __spread(depValues));\n    }\n}\nfunction callNgModuleLifecycle(ngModule, lifecycles) {\n    var def = ngModule._def;\n    var destroyed = new Set();\n    for (var i = 0; i < def.providers.length; i++) {\n        var provDef = def.providers[i];\n        if (provDef.flags & 131072 /* OnDestroy */) {\n            var instance = ngModule._providers[i];\n            if (instance && instance !== UNDEFINED_VALUE) {\n                var onDestroy = instance.ngOnDestroy;\n                if (typeof onDestroy === 'function' && !destroyed.has(instance)) {\n                    onDestroy.apply(instance);\n                    destroyed.add(instance);\n                }\n            }\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 */\nfunction attachEmbeddedView(parentView, elementData, viewIndex, view) {\n    var embeddedViews = elementData.viewContainer._embeddedViews;\n    if (viewIndex === null || viewIndex === undefined) {\n        viewIndex = embeddedViews.length;\n    }\n    view.viewContainerParent = parentView;\n    addToArray(embeddedViews, viewIndex, view);\n    attachProjectedView(elementData, view);\n    Services.dirtyParentQueries(view);\n    var prevView = viewIndex > 0 ? embeddedViews[viewIndex - 1] : null;\n    renderAttachEmbeddedView(elementData, prevView, view);\n}\nfunction attachProjectedView(vcElementData, view) {\n    var dvcElementData = declaredViewContainer(view);\n    if (!dvcElementData || dvcElementData === vcElementData ||\n        view.state & 16 /* 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 across 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 |= 16 /* IsProjectedView */;\n    var 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(view.parent.def, view.parentNodeDef);\n}\nfunction markNodeAsProjectedTemplate(viewDef, nodeDef) {\n    if (nodeDef.flags & 4 /* ProjectedTemplate */) {\n        return;\n    }\n    viewDef.nodeFlags |= 4 /* ProjectedTemplate */;\n    nodeDef.flags |= 4 /* ProjectedTemplate */;\n    var parentNodeDef = nodeDef.parent;\n    while (parentNodeDef) {\n        parentNodeDef.childFlags |= 4 /* ProjectedTemplate */;\n        parentNodeDef = parentNodeDef.parent;\n    }\n}\nfunction detachEmbeddedView(elementData, viewIndex) {\n    var embeddedViews = 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    var view = embeddedViews[viewIndex];\n    view.viewContainerParent = null;\n    removeFromArray(embeddedViews, viewIndex);\n    // See attachProjectedView for why we don't update projectedViews here.\n    Services.dirtyParentQueries(view);\n    renderDetachView(view);\n    return view;\n}\nfunction detachProjectedView(view) {\n    if (!(view.state & 16 /* IsProjectedView */)) {\n        return;\n    }\n    var dvcElementData = declaredViewContainer(view);\n    if (dvcElementData) {\n        var projectedViews = dvcElementData.template._projectedViews;\n        if (projectedViews) {\n            removeFromArray(projectedViews, projectedViews.indexOf(view));\n            Services.dirtyParentQueries(view);\n        }\n    }\n}\nfunction moveEmbeddedView(elementData, oldViewIndex, newViewIndex) {\n    var embeddedViews = elementData.viewContainer._embeddedViews;\n    var view = embeddedViews[oldViewIndex];\n    removeFromArray(embeddedViews, oldViewIndex);\n    if (newViewIndex == null) {\n        newViewIndex = embeddedViews.length;\n    }\n    addToArray(embeddedViews, newViewIndex, view);\n    // Note: Don't need to change projectedViews as the order in there\n    // as always invalid...\n    Services.dirtyParentQueries(view);\n    renderDetachView(view);\n    var prevView = newViewIndex > 0 ? embeddedViews[newViewIndex - 1] : null;\n    renderAttachEmbeddedView(elementData, prevView, view);\n    return view;\n}\nfunction renderAttachEmbeddedView(elementData, prevView, view) {\n    var prevRenderNode = prevView ? renderNode(prevView, prevView.def.lastRenderRootNode) :\n        elementData.renderElement;\n    var parentNode = view.renderer.parentNode(prevRenderNode);\n    var 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, 2 /* InsertBefore */, parentNode, nextSibling, undefined);\n}\nfunction renderDetachView(view) {\n    visitRootRenderNodes(view, 3 /* RemoveChild */, null, null, undefined);\n}\nfunction addToArray(arr, index, value) {\n    // perf: array.push is faster than array.splice!\n    if (index >= arr.length) {\n        arr.push(value);\n    }\n    else {\n        arr.splice(index, 0, value);\n    }\n}\nfunction removeFromArray(arr, index) {\n    // perf: array.pop is faster than array.splice!\n    if (index >= arr.length - 1) {\n        arr.pop();\n    }\n    else {\n        arr.splice(index, 1);\n    }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar EMPTY_CONTEXT = new Object();\n// Attention: this function is called as top level function.\n// Putting any logic in here will destroy closure tree shaking!\nfunction createComponentFactory(selector, componentType, viewDefFactory, inputs, outputs, ngContentSelectors) {\n    return new ComponentFactory_(selector, componentType, viewDefFactory, inputs, outputs, ngContentSelectors);\n}\nfunction getComponentViewDefinitionFactory(componentFactory) {\n    return componentFactory.viewDefFactory;\n}\nvar ComponentFactory_ = /** @class */ (function (_super) {\n    __extends(ComponentFactory_, _super);\n    function ComponentFactory_(selector, componentType, viewDefFactory, _inputs, _outputs, ngContentSelectors) {\n        var _this = \n        // Attention: this ctor is called as top level function.\n        // Putting any logic in here will destroy closure tree shaking!\n        _super.call(this) || this;\n        _this.selector = selector;\n        _this.componentType = componentType;\n        _this._inputs = _inputs;\n        _this._outputs = _outputs;\n        _this.ngContentSelectors = ngContentSelectors;\n        _this.viewDefFactory = viewDefFactory;\n        return _this;\n    }\n    Object.defineProperty(ComponentFactory_.prototype, \"inputs\", {\n        get: function () {\n            var inputsArr = [];\n            var inputs = this._inputs;\n            for (var propName in inputs) {\n                var templateName = inputs[propName];\n                inputsArr.push({ propName: propName, templateName: templateName });\n            }\n            return inputsArr;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ComponentFactory_.prototype, \"outputs\", {\n        get: function () {\n            var outputsArr = [];\n            for (var propName in this._outputs) {\n                var templateName = this._outputs[propName];\n                outputsArr.push({ propName: propName, templateName: templateName });\n            }\n            return outputsArr;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Creates a new component.\n     */\n    ComponentFactory_.prototype.create = function (injector, projectableNodes, rootSelectorOrNode, ngModule) {\n        if (!ngModule) {\n            throw new Error('ngModule should be provided');\n        }\n        var viewDef = resolveDefinition(this.viewDefFactory);\n        var componentNodeIndex = viewDef.nodes[0].element.componentProvider.nodeIndex;\n        var view = Services.createRootView(injector, projectableNodes || [], rootSelectorOrNode, viewDef, ngModule, EMPTY_CONTEXT);\n        var component = asProviderData(view, componentNodeIndex).instance;\n        if (rootSelectorOrNode) {\n            view.renderer.setAttribute(asElementData(view, 0).renderElement, 'ng-version', VERSION.full);\n        }\n        return new ComponentRef_(view, new ViewRef_(view), component);\n    };\n    return ComponentFactory_;\n}(ComponentFactory));\nvar ComponentRef_ = /** @class */ (function (_super) {\n    __extends(ComponentRef_, _super);\n    function ComponentRef_(_view, _viewRef, _component) {\n        var _this = _super.call(this) || this;\n        _this._view = _view;\n        _this._viewRef = _viewRef;\n        _this._component = _component;\n        _this._elDef = _this._view.def.nodes[0];\n        _this.hostView = _viewRef;\n        _this.changeDetectorRef = _viewRef;\n        _this.instance = _component;\n        return _this;\n    }\n    Object.defineProperty(ComponentRef_.prototype, \"location\", {\n        get: function () {\n            return new ElementRef(asElementData(this._view, this._elDef.nodeIndex).renderElement);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ComponentRef_.prototype, \"injector\", {\n        get: function () { return new Injector_(this._view, this._elDef); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ComponentRef_.prototype, \"componentType\", {\n        get: function () { return this._component.constructor; },\n        enumerable: true,\n        configurable: true\n    });\n    ComponentRef_.prototype.destroy = function () { this._viewRef.destroy(); };\n    ComponentRef_.prototype.onDestroy = function (callback) { this._viewRef.onDestroy(callback); };\n    return ComponentRef_;\n}(ComponentRef));\nfunction createViewContainerData(view, elDef, elData) {\n    return new ViewContainerRef_(view, elDef, elData);\n}\nvar ViewContainerRef_ = /** @class */ (function () {\n    function ViewContainerRef_(_view, _elDef, _data) {\n        this._view = _view;\n        this._elDef = _elDef;\n        this._data = _data;\n        /**\n         * @internal\n         */\n        this._embeddedViews = [];\n    }\n    Object.defineProperty(ViewContainerRef_.prototype, \"element\", {\n        get: function () { return new ElementRef(this._data.renderElement); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewContainerRef_.prototype, \"injector\", {\n        get: function () { return new Injector_(this._view, this._elDef); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewContainerRef_.prototype, \"parentInjector\", {\n        get: function () {\n            var view = this._view;\n            var elDef = this._elDef.parent;\n            while (!elDef && view) {\n                elDef = viewParentEl(view);\n                view = view.parent;\n            }\n            return view ? new Injector_(view, elDef) : new Injector_(this._view, null);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ViewContainerRef_.prototype.clear = function () {\n        var len = this._embeddedViews.length;\n        for (var i = len - 1; i >= 0; i--) {\n            var view = detachEmbeddedView(this._data, i);\n            Services.destroyView(view);\n        }\n    };\n    ViewContainerRef_.prototype.get = function (index) {\n        var view = this._embeddedViews[index];\n        if (view) {\n            var ref = new ViewRef_(view);\n            ref.attachToViewContainerRef(this);\n            return ref;\n        }\n        return null;\n    };\n    Object.defineProperty(ViewContainerRef_.prototype, \"length\", {\n        get: function () { return this._embeddedViews.length; },\n        enumerable: true,\n        configurable: true\n    });\n    ViewContainerRef_.prototype.createEmbeddedView = function (templateRef, context, index) {\n        var viewRef = templateRef.createEmbeddedView(context || {});\n        this.insert(viewRef, index);\n        return viewRef;\n    };\n    ViewContainerRef_.prototype.createComponent = function (componentFactory, index, injector, projectableNodes, ngModuleRef) {\n        var contextInjector = injector || this.parentInjector;\n        if (!ngModuleRef && !(componentFactory instanceof ComponentFactoryBoundToModule)) {\n            ngModuleRef = contextInjector.get(NgModuleRef);\n        }\n        var componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);\n        this.insert(componentRef.hostView, index);\n        return componentRef;\n    };\n    ViewContainerRef_.prototype.insert = function (viewRef, index) {\n        if (viewRef.destroyed) {\n            throw new Error('Cannot insert a destroyed View in a ViewContainer!');\n        }\n        var viewRef_ = viewRef;\n        var viewData = viewRef_._view;\n        attachEmbeddedView(this._view, this._data, index, viewData);\n        viewRef_.attachToViewContainerRef(this);\n        return viewRef;\n    };\n    ViewContainerRef_.prototype.move = function (viewRef, currentIndex) {\n        if (viewRef.destroyed) {\n            throw new Error('Cannot move a destroyed View in a ViewContainer!');\n        }\n        var previousIndex = this._embeddedViews.indexOf(viewRef._view);\n        moveEmbeddedView(this._data, previousIndex, currentIndex);\n        return viewRef;\n    };\n    ViewContainerRef_.prototype.indexOf = function (viewRef) {\n        return this._embeddedViews.indexOf(viewRef._view);\n    };\n    ViewContainerRef_.prototype.remove = function (index) {\n        var viewData = detachEmbeddedView(this._data, index);\n        if (viewData) {\n            Services.destroyView(viewData);\n        }\n    };\n    ViewContainerRef_.prototype.detach = function (index) {\n        var view = detachEmbeddedView(this._data, index);\n        return view ? new ViewRef_(view) : null;\n    };\n    return ViewContainerRef_;\n}());\nfunction createChangeDetectorRef(view) {\n    return new ViewRef_(view);\n}\nvar ViewRef_ = /** @class */ (function () {\n    function ViewRef_(_view) {\n        this._view = _view;\n        this._viewContainerRef = null;\n        this._appRef = null;\n    }\n    Object.defineProperty(ViewRef_.prototype, \"rootNodes\", {\n        get: function () { return rootRenderNodes(this._view); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewRef_.prototype, \"context\", {\n        get: function () { return this._view.context; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ViewRef_.prototype, \"destroyed\", {\n        get: function () { return (this._view.state & 128 /* Destroyed */) !== 0; },\n        enumerable: true,\n        configurable: true\n    });\n    ViewRef_.prototype.markForCheck = function () { markParentViewsForCheck(this._view); };\n    ViewRef_.prototype.detach = function () { this._view.state &= ~4 /* Attached */; };\n    ViewRef_.prototype.detectChanges = function () {\n        var fs = this._view.root.rendererFactory;\n        if (fs.begin) {\n            fs.begin();\n        }\n        try {\n            Services.checkAndUpdateView(this._view);\n        }\n        finally {\n            if (fs.end) {\n                fs.end();\n            }\n        }\n    };\n    ViewRef_.prototype.checkNoChanges = function () { Services.checkNoChangesView(this._view); };\n    ViewRef_.prototype.reattach = function () { this._view.state |= 4 /* Attached */; };\n    ViewRef_.prototype.onDestroy = function (callback) {\n        if (!this._view.disposables) {\n            this._view.disposables = [];\n        }\n        this._view.disposables.push(callback);\n    };\n    ViewRef_.prototype.destroy = function () {\n        if (this._appRef) {\n            this._appRef.detachView(this);\n        }\n        else if (this._viewContainerRef) {\n            this._viewContainerRef.detach(this._viewContainerRef.indexOf(this));\n        }\n        Services.destroyView(this._view);\n    };\n    ViewRef_.prototype.detachFromAppRef = function () {\n        this._appRef = null;\n        renderDetachView(this._view);\n        Services.dirtyParentQueries(this._view);\n    };\n    ViewRef_.prototype.attachToAppRef = function (appRef) {\n        if (this._viewContainerRef) {\n            throw new Error('This view is already attached to a ViewContainer!');\n        }\n        this._appRef = appRef;\n    };\n    ViewRef_.prototype.attachToViewContainerRef = function (vcRef) {\n        if (this._appRef) {\n            throw new Error('This view is already attached directly to the ApplicationRef!');\n        }\n        this._viewContainerRef = vcRef;\n    };\n    return ViewRef_;\n}());\nfunction createTemplateData(view, def) {\n    return new TemplateRef_(view, def);\n}\nvar TemplateRef_ = /** @class */ (function (_super) {\n    __extends(TemplateRef_, _super);\n    function TemplateRef_(_parentView, _def) {\n        var _this = _super.call(this) || this;\n        _this._parentView = _parentView;\n        _this._def = _def;\n        return _this;\n    }\n    TemplateRef_.prototype.createEmbeddedView = function (context) {\n        return new ViewRef_(Services.createEmbeddedView(this._parentView, this._def, this._def.element.template, context));\n    };\n    Object.defineProperty(TemplateRef_.prototype, \"elementRef\", {\n        get: function () {\n            return new ElementRef(asElementData(this._parentView, this._def.nodeIndex).renderElement);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return TemplateRef_;\n}(TemplateRef));\nfunction createInjector$1(view, elDef) {\n    return new Injector_(view, elDef);\n}\nvar Injector_ = /** @class */ (function () {\n    function Injector_(view, elDef) {\n        this.view = view;\n        this.elDef = elDef;\n    }\n    Injector_.prototype.get = function (token, notFoundValue) {\n        if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n        var allowPrivateServices = this.elDef ? (this.elDef.flags & 33554432 /* ComponentView */) !== 0 : false;\n        return Services.resolveDep(this.view, this.elDef, allowPrivateServices, { flags: 0 /* None */, token: token, tokenKey: tokenKey(token) }, notFoundValue);\n    };\n    return Injector_;\n}());\nfunction nodeValue(view, index) {\n    var def = view.def.nodes[index];\n    if (def.flags & 1 /* TypeElement */) {\n        var elData = asElementData(view, def.nodeIndex);\n        return def.element.template ? elData.template : elData.renderElement;\n    }\n    else if (def.flags & 2 /* TypeText */) {\n        return asTextData(view, def.nodeIndex).renderText;\n    }\n    else if (def.flags & (20224 /* CatProvider */ | 16 /* TypePipe */)) {\n        return asProviderData(view, def.nodeIndex).instance;\n    }\n    throw new Error(\"Illegal state: read nodeValue for node index \" + index);\n}\nfunction createRendererV1(view) {\n    return new RendererAdapter(view.renderer);\n}\nvar RendererAdapter = /** @class */ (function () {\n    function RendererAdapter(delegate) {\n        this.delegate = delegate;\n    }\n    RendererAdapter.prototype.selectRootElement = function (selectorOrNode) {\n        return this.delegate.selectRootElement(selectorOrNode);\n    };\n    RendererAdapter.prototype.createElement = function (parent, namespaceAndName) {\n        var _a = __read(splitNamespace(namespaceAndName), 2), ns = _a[0], name = _a[1];\n        var el = this.delegate.createElement(name, ns);\n        if (parent) {\n            this.delegate.appendChild(parent, el);\n        }\n        return el;\n    };\n    RendererAdapter.prototype.createViewRoot = function (hostElement) { return hostElement; };\n    RendererAdapter.prototype.createTemplateAnchor = function (parentElement) {\n        var comment = this.delegate.createComment('');\n        if (parentElement) {\n            this.delegate.appendChild(parentElement, comment);\n        }\n        return comment;\n    };\n    RendererAdapter.prototype.createText = function (parentElement, value) {\n        var node = this.delegate.createText(value);\n        if (parentElement) {\n            this.delegate.appendChild(parentElement, node);\n        }\n        return node;\n    };\n    RendererAdapter.prototype.projectNodes = function (parentElement, nodes) {\n        for (var i = 0; i < nodes.length; i++) {\n            this.delegate.appendChild(parentElement, nodes[i]);\n        }\n    };\n    RendererAdapter.prototype.attachViewAfter = function (node, viewRootNodes) {\n        var parentElement = this.delegate.parentNode(node);\n        var nextSibling = this.delegate.nextSibling(node);\n        for (var i = 0; i < viewRootNodes.length; i++) {\n            this.delegate.insertBefore(parentElement, viewRootNodes[i], nextSibling);\n        }\n    };\n    RendererAdapter.prototype.detachView = function (viewRootNodes) {\n        for (var i = 0; i < viewRootNodes.length; i++) {\n            var node = viewRootNodes[i];\n            var parentElement = this.delegate.parentNode(node);\n            this.delegate.removeChild(parentElement, node);\n        }\n    };\n    RendererAdapter.prototype.destroyView = function (hostElement, viewAllNodes) {\n        for (var i = 0; i < viewAllNodes.length; i++) {\n            this.delegate.destroyNode(viewAllNodes[i]);\n        }\n    };\n    RendererAdapter.prototype.listen = function (renderElement, name, callback) {\n        return this.delegate.listen(renderElement, name, callback);\n    };\n    RendererAdapter.prototype.listenGlobal = function (target, name, callback) {\n        return this.delegate.listen(target, name, callback);\n    };\n    RendererAdapter.prototype.setElementProperty = function (renderElement, propertyName, propertyValue) {\n        this.delegate.setProperty(renderElement, propertyName, propertyValue);\n    };\n    RendererAdapter.prototype.setElementAttribute = function (renderElement, namespaceAndName, attributeValue) {\n        var _a = __read(splitNamespace(namespaceAndName), 2), ns = _a[0], name = _a[1];\n        if (attributeValue != null) {\n            this.delegate.setAttribute(renderElement, name, attributeValue, ns);\n        }\n        else {\n            this.delegate.removeAttribute(renderElement, name, ns);\n        }\n    };\n    RendererAdapter.prototype.setBindingDebugInfo = function (renderElement, propertyName, propertyValue) { };\n    RendererAdapter.prototype.setElementClass = function (renderElement, className, isAdd) {\n        if (isAdd) {\n            this.delegate.addClass(renderElement, className);\n        }\n        else {\n            this.delegate.removeClass(renderElement, className);\n        }\n    };\n    RendererAdapter.prototype.setElementStyle = function (renderElement, styleName, styleValue) {\n        if (styleValue != null) {\n            this.delegate.setStyle(renderElement, styleName, styleValue);\n        }\n        else {\n            this.delegate.removeStyle(renderElement, styleName);\n        }\n    };\n    RendererAdapter.prototype.invokeElementMethod = function (renderElement, methodName, args) {\n        renderElement[methodName].apply(renderElement, args);\n    };\n    RendererAdapter.prototype.setText = function (renderNode$$1, text) { this.delegate.setValue(renderNode$$1, text); };\n    RendererAdapter.prototype.animate = function () { throw new Error('Renderer.animate is no longer supported!'); };\n    return RendererAdapter;\n}());\nfunction createNgModuleRef(moduleType, parent, bootstrapComponents, def) {\n    return new NgModuleRef_(moduleType, parent, bootstrapComponents, def);\n}\nvar NgModuleRef_ = /** @class */ (function () {\n    function NgModuleRef_(_moduleType, _parent, _bootstrapComponents, _def) {\n        this._moduleType = _moduleType;\n        this._parent = _parent;\n        this._bootstrapComponents = _bootstrapComponents;\n        this._def = _def;\n        this._destroyListeners = [];\n        this._destroyed = false;\n        this.injector = this;\n        initNgModule(this);\n    }\n    NgModuleRef_.prototype.get = function (token, notFoundValue, injectFlags) {\n        if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n        if (injectFlags === void 0) { injectFlags = 0 /* Default */; }\n        var flags = 0;\n        if (injectFlags & 4 /* SkipSelf */) {\n            flags |= 1 /* SkipSelf */;\n        }\n        else if (injectFlags & 2 /* Self */) {\n            flags |= 4 /* Self */;\n        }\n        return resolveNgModuleDep(this, { token: token, tokenKey: tokenKey(token), flags: flags }, notFoundValue);\n    };\n    Object.defineProperty(NgModuleRef_.prototype, \"instance\", {\n        get: function () { return this.get(this._moduleType); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NgModuleRef_.prototype, \"componentFactoryResolver\", {\n        get: function () { return this.get(ComponentFactoryResolver); },\n        enumerable: true,\n        configurable: true\n    });\n    NgModuleRef_.prototype.destroy = function () {\n        if (this._destroyed) {\n            throw new Error(\"The ng module \" + stringify(this.instance.constructor) + \" has already been destroyed.\");\n        }\n        this._destroyed = true;\n        callNgModuleLifecycle(this, 131072 /* OnDestroy */);\n        this._destroyListeners.forEach(function (listener) { return listener(); });\n    };\n    NgModuleRef_.prototype.onDestroy = function (callback) { this._destroyListeners.push(callback); };\n    return NgModuleRef_;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar RendererV1TokenKey = tokenKey(Renderer);\nvar Renderer2TokenKey = tokenKey(Renderer2);\nvar ElementRefTokenKey = tokenKey(ElementRef);\nvar ViewContainerRefTokenKey = tokenKey(ViewContainerRef);\nvar TemplateRefTokenKey = tokenKey(TemplateRef);\nvar ChangeDetectorRefTokenKey = tokenKey(ChangeDetectorRef);\nvar InjectorRefTokenKey = tokenKey(Injector);\nvar INJECTORRefTokenKey = tokenKey(INJECTOR);\nfunction directiveDef(checkIndex, flags, matchedQueries, childCount, ctor, deps, props, outputs) {\n    var bindings = [];\n    if (props) {\n        for (var prop in props) {\n            var _a = __read(props[prop], 2), bindingIndex = _a[0], nonMinifiedName = _a[1];\n            bindings[bindingIndex] = {\n                flags: 8 /* TypeProperty */,\n                name: prop, nonMinifiedName: nonMinifiedName,\n                ns: null,\n                securityContext: null,\n                suffix: null\n            };\n        }\n    }\n    var outputDefs = [];\n    if (outputs) {\n        for (var propName in outputs) {\n            outputDefs.push({ type: 1 /* DirectiveOutput */, propName: propName, target: null, eventName: outputs[propName] });\n        }\n    }\n    flags |= 16384 /* TypeDirective */;\n    return _def(checkIndex, flags, matchedQueries, childCount, ctor, ctor, deps, bindings, outputDefs);\n}\nfunction pipeDef(flags, ctor, deps) {\n    flags |= 16 /* TypePipe */;\n    return _def(-1, flags, null, 0, ctor, ctor, deps);\n}\nfunction providerDef(flags, matchedQueries, token, value, deps) {\n    return _def(-1, flags, matchedQueries, 0, token, value, deps);\n}\nfunction _def(checkIndex, flags, matchedQueriesDsl, childCount, token, value, deps, bindings, outputs) {\n    var _a = splitMatchedQueriesDsl(matchedQueriesDsl), matchedQueries = _a.matchedQueries, references = _a.references, matchedQueryIds = _a.matchedQueryIds;\n    if (!outputs) {\n        outputs = [];\n    }\n    if (!bindings) {\n        bindings = [];\n    }\n    // Need to resolve forwardRefs as e.g. for `useValue` we\n    // lowered the expression and then stopped evaluating it,\n    // i.e. also didn't unwrap it.\n    value = resolveForwardRef(value);\n    var depDefs = splitDepsDsl(deps, stringify(token));\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: flags,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0, matchedQueries: matchedQueries, matchedQueryIds: matchedQueryIds, references: references,\n        ngContentIndex: -1, childCount: childCount, bindings: bindings,\n        bindingFlags: calcBindingFlags(bindings), outputs: outputs,\n        element: null,\n        provider: { token: token, value: value, deps: depDefs },\n        text: null,\n        query: null,\n        ngContent: null\n    };\n}\nfunction createProviderInstance(view, def) {\n    return _createProviderInstance(view, def);\n}\nfunction createPipeInstance(view, def) {\n    // deps are looked up from component.\n    var compView = view;\n    while (compView.parent && !isComponentView(compView)) {\n        compView = compView.parent;\n    }\n    // pipes can see the private services of the component\n    var allowPrivateServices = true;\n    // pipes are always eager and classes!\n    return createClass(compView.parent, viewParentEl(compView), allowPrivateServices, def.provider.value, def.provider.deps);\n}\nfunction createDirectiveInstance(view, def) {\n    // components can see other private services, other directives can't.\n    var allowPrivateServices = (def.flags & 32768 /* Component */) > 0;\n    // directives are always eager and classes!\n    var instance = createClass(view, def.parent, allowPrivateServices, def.provider.value, def.provider.deps);\n    if (def.outputs.length) {\n        for (var i = 0; i < def.outputs.length; i++) {\n            var output = def.outputs[i];\n            var subscription = instance[output.propName].subscribe(eventHandlerClosure(view, def.parent.nodeIndex, output.eventName));\n            view.disposables[def.outputIndex + i] = subscription.unsubscribe.bind(subscription);\n        }\n    }\n    return instance;\n}\nfunction eventHandlerClosure(view, index, eventName) {\n    return function (event) { return dispatchEvent(view, index, eventName, event); };\n}\nfunction checkAndUpdateDirectiveInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var providerData = asProviderData(view, def.nodeIndex);\n    var directive = providerData.instance;\n    var changed = false;\n    var changes = undefined;\n    var 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 ((def.flags & 65536 /* OnInit */) &&\n        shouldCallLifecycleInitHook(view, 256 /* InitState_CallingOnInit */, def.nodeIndex)) {\n        directive.ngOnInit();\n    }\n    if (def.flags & 262144 /* DoCheck */) {\n        directive.ngDoCheck();\n    }\n    return changed;\n}\nfunction checkAndUpdateDirectiveDynamic(view, def, values) {\n    var providerData = asProviderData(view, def.nodeIndex);\n    var directive = providerData.instance;\n    var changed = false;\n    var changes = undefined;\n    for (var 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 ((def.flags & 65536 /* OnInit */) &&\n        shouldCallLifecycleInitHook(view, 256 /* InitState_CallingOnInit */, def.nodeIndex)) {\n        directive.ngOnInit();\n    }\n    if (def.flags & 262144 /* DoCheck */) {\n        directive.ngDoCheck();\n    }\n    return changed;\n}\nfunction _createProviderInstance(view, def) {\n    // private services can see other private services\n    var allowPrivateServices = (def.flags & 8192 /* PrivateProvider */) > 0;\n    var providerDef = def.provider;\n    switch (def.flags & 201347067 /* Types */) {\n        case 512 /* TypeClassProvider */:\n            return createClass(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);\n        case 1024 /* TypeFactoryProvider */:\n            return callFactory(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);\n        case 2048 /* TypeUseExistingProvider */:\n            return resolveDep(view, def.parent, allowPrivateServices, providerDef.deps[0]);\n        case 256 /* TypeValueProvider */:\n            return providerDef.value;\n    }\n}\nfunction createClass(view, elDef, allowPrivateServices, ctor, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return new ctor();\n        case 1:\n            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n        case 2:\n            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]));\n        case 3:\n            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]), resolveDep(view, elDef, allowPrivateServices, deps[2]));\n        default:\n            var depValues = new Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);\n            }\n            return new (ctor.bind.apply(ctor, __spread([void 0], depValues)))();\n    }\n}\nfunction callFactory(view, elDef, allowPrivateServices, factory, deps) {\n    var len = deps.length;\n    switch (len) {\n        case 0:\n            return factory();\n        case 1:\n            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n        case 2:\n            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]));\n        case 3:\n            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]), resolveDep(view, elDef, allowPrivateServices, deps[2]));\n        default:\n            var depValues = Array(len);\n            for (var i = 0; i < len; i++) {\n                depValues[i] = resolveDep(view, elDef, allowPrivateServices, deps[i]);\n            }\n            return factory.apply(void 0, __spread(depValues));\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)\nvar NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};\nfunction resolveDep(view, elDef, allowPrivateServices, depDef, notFoundValue) {\n    if (notFoundValue === void 0) { notFoundValue = Injector.THROW_IF_NOT_FOUND; }\n    if (depDef.flags & 8 /* Value */) {\n        return depDef.token;\n    }\n    var startView = view;\n    if (depDef.flags & 2 /* Optional */) {\n        notFoundValue = null;\n    }\n    var tokenKey$$1 = depDef.tokenKey;\n    if (tokenKey$$1 === 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 && elDef.element.componentView);\n    }\n    if (elDef && (depDef.flags & 1 /* SkipSelf */)) {\n        allowPrivateServices = false;\n        elDef = elDef.parent;\n    }\n    var searchView = view;\n    while (searchView) {\n        if (elDef) {\n            switch (tokenKey$$1) {\n                case RendererV1TokenKey: {\n                    var compView = findCompView(searchView, elDef, allowPrivateServices);\n                    return createRendererV1(compView);\n                }\n                case Renderer2TokenKey: {\n                    var compView = findCompView(searchView, elDef, allowPrivateServices);\n                    return compView.renderer;\n                }\n                case ElementRefTokenKey:\n                    return new ElementRef(asElementData(searchView, elDef.nodeIndex).renderElement);\n                case ViewContainerRefTokenKey:\n                    return asElementData(searchView, elDef.nodeIndex).viewContainer;\n                case TemplateRefTokenKey: {\n                    if (elDef.element.template) {\n                        return asElementData(searchView, elDef.nodeIndex).template;\n                    }\n                    break;\n                }\n                case ChangeDetectorRefTokenKey: {\n                    var cdView = findCompView(searchView, elDef, allowPrivateServices);\n                    return createChangeDetectorRef(cdView);\n                }\n                case InjectorRefTokenKey:\n                case INJECTORRefTokenKey:\n                    return createInjector$1(searchView, elDef);\n                default:\n                    var providerDef_1 = (allowPrivateServices ? elDef.element.allProviders :\n                        elDef.element.publicProviders)[tokenKey$$1];\n                    if (providerDef_1) {\n                        var providerData = asProviderData(searchView, providerDef_1.nodeIndex);\n                        if (!providerData) {\n                            providerData = { instance: _createProviderInstance(searchView, providerDef_1) };\n                            searchView.nodes[providerDef_1.nodeIndex] = providerData;\n                        }\n                        return providerData.instance;\n                    }\n            }\n        }\n        allowPrivateServices = isComponentView(searchView);\n        elDef = viewParentEl(searchView);\n        searchView = searchView.parent;\n        if (depDef.flags & 4 /* Self */) {\n            searchView = null;\n        }\n    }\n    var value = startView.root.injector.get(depDef.token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);\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    return startView.root.ngModule.injector.get(depDef.token, notFoundValue);\n}\nfunction findCompView(view, elDef, allowPrivateServices) {\n    var compView;\n    if (allowPrivateServices) {\n        compView = asElementData(view, elDef.nodeIndex).componentView;\n    }\n    else {\n        compView = view;\n        while (compView.parent && !isComponentView(compView)) {\n            compView = compView.parent;\n        }\n    }\n    return compView;\n}\nfunction updateProp(view, providerData, def, bindingIdx, value, changes) {\n    if (def.flags & 32768 /* Component */) {\n        var compView = asElementData(view, def.parent.nodeIndex).componentView;\n        if (compView.def.flags & 2 /* OnPush */) {\n            compView.state |= 8 /* ChecksEnabled */;\n        }\n    }\n    var binding = def.bindings[bindingIdx];\n    var propName = 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 & 524288 /* OnChanges */) {\n        changes = changes || {};\n        var oldValue = WrappedValue.unwrap(view.oldValues[def.bindingIndex + bindingIdx]);\n        var binding_1 = def.bindings[bindingIdx];\n        changes[binding_1.nonMinifiedName] =\n            new SimpleChange(oldValue, value, (view.state & 2 /* FirstCheck */) !== 0);\n    }\n    view.oldValues[def.bindingIndex + bindingIdx] = value;\n    return changes;\n}\n// This function calls the ngAfterContentCheck, ngAfterContentInit,\n// ngAfterViewCheck, and ngAfterViewInit lifecycle hooks (depending on the node\n// flags in lifecycle). Unlike ngDoCheck, ngOnChanges and ngOnInit, which are\n// called during a pre-order traversal of the view tree (that is calling the\n// parent hooks before the child hooks) these events are sent in using a\n// post-order traversal of the tree (children before parents). This changes the\n// meaning of initIndex in the view state. For ngOnInit, initIndex tracks the\n// expected nodeIndex which a ngOnInit should be called. When sending\n// ngAfterContentInit and ngAfterViewInit it is the expected count of\n// ngAfterContentInit or ngAfterViewInit methods that have been called. This\n// ensure that despite being called recursively or after picking up after an\n// exception, the ngAfterContentInit or ngAfterViewInit will be called on the\n// correct nodes. Consider for example, the following (where E is an element\n// and D is a directive)\n//  Tree:       pre-order index  post-order index\n//    E1        0                6\n//      E2      1                1\n//       D3     2                0\n//      E4      3                5\n//       E5     4                4\n//        E6    5                2\n//        E7    6                3\n// As can be seen, the post-order index has an unclear relationship to the\n// pre-order index (postOrderIndex === preOrderIndex - parentCount +\n// childCount). Since number of calls to ngAfterContentInit and ngAfterViewInit\n// are stable (will be the same for the same view regardless of exceptions or\n// recursion) we just need to count them which will roughly correspond to the\n// post-order index (it skips elements and directives that do not have\n// lifecycle hooks).\n//\n// For example, if an exception is raised in the E6.onAfterViewInit() the\n// initIndex is left at 3 (by shouldCallLifecycleInitHook() which set it to\n// initIndex + 1). When checkAndUpdateView() is called again D3, E2 and E6 will\n// not have their ngAfterViewInit() called but, starting with E7, the rest of\n// the view will begin getting ngAfterViewInit() called until a check and\n// pass is complete.\n//\n// This algorthim also handles recursion. Consider if E4's ngAfterViewInit()\n// indirectly calls E1's ChangeDetectorRef.detectChanges(). The expected\n// initIndex is set to 6, the recusive checkAndUpdateView() starts walk again.\n// D3, E2, E6, E7, E5 and E4 are skipped, ngAfterViewInit() is called on E1.\n// When the recursion returns the initIndex will be 7 so E1 is skipped as it\n// has already been called in the recursively called checkAnUpdateView().\nfunction callLifecycleHooksChildrenFirst(view, lifecycles) {\n    if (!(view.def.nodeFlags & lifecycles)) {\n        return;\n    }\n    var nodes = view.def.nodes;\n    var initIndex = 0;\n    for (var i = 0; i < nodes.length; i++) {\n        var nodeDef = nodes[i];\n        var parent_1 = nodeDef.parent;\n        if (!parent_1 && nodeDef.flags & lifecycles) {\n            // matching root node (e.g. a pipe)\n            callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);\n        }\n        if ((nodeDef.childFlags & lifecycles) === 0) {\n            // no child matches one of the lifecycles\n            i += nodeDef.childCount;\n        }\n        while (parent_1 && (parent_1.flags & 1 /* TypeElement */) &&\n            i === parent_1.nodeIndex + parent_1.childCount) {\n            // last child of an element\n            if (parent_1.directChildFlags & lifecycles) {\n                initIndex = callElementProvidersLifecycles(view, parent_1, lifecycles, initIndex);\n            }\n            parent_1 = parent_1.parent;\n        }\n    }\n}\nfunction callElementProvidersLifecycles(view, elDef, lifecycles, initIndex) {\n    for (var i = elDef.nodeIndex + 1; i <= elDef.nodeIndex + elDef.childCount; i++) {\n        var nodeDef = view.def.nodes[i];\n        if (nodeDef.flags & lifecycles) {\n            callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);\n        }\n        // only visit direct children\n        i += nodeDef.childCount;\n    }\n    return initIndex;\n}\nfunction callProviderLifecycles(view, index, lifecycles, initIndex) {\n    var providerData = asProviderData(view, index);\n    if (!providerData) {\n        return;\n    }\n    var provider = providerData.instance;\n    if (!provider) {\n        return;\n    }\n    Services.setCurrentNode(view, index);\n    if (lifecycles & 1048576 /* AfterContentInit */ &&\n        shouldCallLifecycleInitHook(view, 512 /* InitState_CallingAfterContentInit */, initIndex)) {\n        provider.ngAfterContentInit();\n    }\n    if (lifecycles & 2097152 /* AfterContentChecked */) {\n        provider.ngAfterContentChecked();\n    }\n    if (lifecycles & 4194304 /* AfterViewInit */ &&\n        shouldCallLifecycleInitHook(view, 768 /* InitState_CallingAfterViewInit */, initIndex)) {\n        provider.ngAfterViewInit();\n    }\n    if (lifecycles & 8388608 /* AfterViewChecked */) {\n        provider.ngAfterViewChecked();\n    }\n    if (lifecycles & 131072 /* OnDestroy */) {\n        provider.ngOnDestroy();\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 */\nfunction queryDef(flags, id, bindings) {\n    var bindingDefs = [];\n    for (var propName in bindings) {\n        var bindingType = bindings[propName];\n        bindingDefs.push({ propName: propName, bindingType: bindingType });\n    }\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        // TODO(vicb): check\n        checkIndex: -1, flags: 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: id, filterId: filterQueryId(id), bindings: bindingDefs },\n        ngContent: null\n    };\n}\nfunction createQuery() {\n    return new QueryList();\n}\nfunction dirtyParentQueries(view) {\n    var queryIds = view.def.nodeMatchedQueries;\n    while (view.parent && isEmbeddedView(view)) {\n        var tplDef = view.parentNodeDef;\n        view = view.parent;\n        // content queries\n        var end = tplDef.nodeIndex + tplDef.childCount;\n        for (var i = 0; i <= end; i++) {\n            var nodeDef = view.def.nodes[i];\n            if ((nodeDef.flags & 67108864 /* TypeContentQuery */) &&\n                (nodeDef.flags & 536870912 /* DynamicQuery */) &&\n                (nodeDef.query.filterId & queryIds) === nodeDef.query.filterId) {\n                asQueryList(view, i).setDirty();\n            }\n            if ((nodeDef.flags & 1 /* TypeElement */ && i + nodeDef.childCount < tplDef.nodeIndex) ||\n                !(nodeDef.childFlags & 67108864 /* TypeContentQuery */) ||\n                !(nodeDef.childFlags & 536870912 /* DynamicQuery */)) {\n                // skip elements that don't contain the template element or no query.\n                i += nodeDef.childCount;\n            }\n        }\n    }\n    // view queries\n    if (view.def.nodeFlags & 134217728 /* TypeViewQuery */) {\n        for (var i = 0; i < view.def.nodes.length; i++) {\n            var nodeDef = view.def.nodes[i];\n            if ((nodeDef.flags & 134217728 /* TypeViewQuery */) && (nodeDef.flags & 536870912 /* DynamicQuery */)) {\n                asQueryList(view, i).setDirty();\n            }\n            // only visit the root nodes\n            i += nodeDef.childCount;\n        }\n    }\n}\nfunction checkAndUpdateQuery(view, nodeDef) {\n    var queryList = asQueryList(view, nodeDef.nodeIndex);\n    if (!queryList.dirty) {\n        return;\n    }\n    var directiveInstance;\n    var newValues = undefined;\n    if (nodeDef.flags & 67108864 /* TypeContentQuery */) {\n        var elementDef = nodeDef.parent.parent;\n        newValues = calcQueryValues(view, elementDef.nodeIndex, elementDef.nodeIndex + elementDef.childCount, nodeDef.query, []);\n        directiveInstance = asProviderData(view, nodeDef.parent.nodeIndex).instance;\n    }\n    else if (nodeDef.flags & 134217728 /* TypeViewQuery */) {\n        newValues = calcQueryValues(view, 0, view.def.nodes.length - 1, nodeDef.query, []);\n        directiveInstance = view.component;\n    }\n    queryList.reset(newValues);\n    var bindings = nodeDef.query.bindings;\n    var notify = false;\n    for (var i = 0; i < bindings.length; i++) {\n        var binding = bindings[i];\n        var boundValue = void 0;\n        switch (binding.bindingType) {\n            case 0 /* First */:\n                boundValue = queryList.first;\n                break;\n            case 1 /* All */:\n                boundValue = queryList;\n                notify = true;\n                break;\n        }\n        directiveInstance[binding.propName] = boundValue;\n    }\n    if (notify) {\n        queryList.notifyOnChanges();\n    }\n}\nfunction calcQueryValues(view, startIndex, endIndex, queryDef, values) {\n    for (var i = startIndex; i <= endIndex; i++) {\n        var nodeDef = view.def.nodes[i];\n        var valueType = nodeDef.matchedQueries[queryDef.id];\n        if (valueType != null) {\n            values.push(getQueryValue(view, nodeDef, valueType));\n        }\n        if (nodeDef.flags & 1 /* TypeElement */ && nodeDef.element.template &&\n            (nodeDef.element.template.nodeMatchedQueries & queryDef.filterId) ===\n                queryDef.filterId) {\n            var elementData = asElementData(view, i);\n            // check embedded views that were attached at the place of their template,\n            // but process child nodes first if some match the query (see issue #16568)\n            if ((nodeDef.childMatchedQueries & queryDef.filterId) === queryDef.filterId) {\n                calcQueryValues(view, i + 1, i + nodeDef.childCount, queryDef, values);\n                i += nodeDef.childCount;\n            }\n            if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n                var embeddedViews = elementData.viewContainer._embeddedViews;\n                for (var k = 0; k < embeddedViews.length; k++) {\n                    var embeddedView = embeddedViews[k];\n                    var dvc = declaredViewContainer(embeddedView);\n                    if (dvc && dvc === elementData) {\n                        calcQueryValues(embeddedView, 0, embeddedView.def.nodes.length - 1, queryDef, values);\n                    }\n                }\n            }\n            var projectedViews = elementData.template._projectedViews;\n            if (projectedViews) {\n                for (var k = 0; k < projectedViews.length; k++) {\n                    var 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}\nfunction getQueryValue(view, nodeDef, queryValueType) {\n    if (queryValueType != null) {\n        // a match\n        switch (queryValueType) {\n            case 1 /* RenderElement */:\n                return asElementData(view, nodeDef.nodeIndex).renderElement;\n            case 0 /* ElementRef */:\n                return new ElementRef(asElementData(view, nodeDef.nodeIndex).renderElement);\n            case 2 /* TemplateRef */:\n                return asElementData(view, nodeDef.nodeIndex).template;\n            case 3 /* ViewContainerRef */:\n                return asElementData(view, nodeDef.nodeIndex).viewContainer;\n            case 4 /* Provider */:\n                return asProviderData(view, nodeDef.nodeIndex).instance;\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 */\nfunction ngContentDef(ngContentIndex, index) {\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: -1,\n        flags: 8 /* TypeNgContent */,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0,\n        matchedQueries: {},\n        matchedQueryIds: 0,\n        references: {}, ngContentIndex: 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: index }\n    };\n}\nfunction appendNgContent(view, renderHost, def) {\n    var parentEl = getParentRenderElement(view, renderHost, def);\n    if (!parentEl) {\n        // Nothing to do if there is no parent element.\n        return;\n    }\n    var ngContentIndex = def.ngContent.index;\n    visitProjectedRenderNodes(view, ngContentIndex, 1 /* AppendChild */, parentEl, null, undefined);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction purePipeDef(checkIndex, argCount) {\n    // argCount + 1 to include the pipe as first arg\n    return _pureExpressionDef(128 /* TypePurePipe */, checkIndex, new Array(argCount + 1));\n}\nfunction pureArrayDef(checkIndex, argCount) {\n    return _pureExpressionDef(32 /* TypePureArray */, checkIndex, new Array(argCount));\n}\nfunction pureObjectDef(checkIndex, propToIndex) {\n    var keys = Object.keys(propToIndex);\n    var nbKeys = keys.length;\n    var propertyNames = new Array(nbKeys);\n    for (var i = 0; i < nbKeys; i++) {\n        var key = keys[i];\n        var index = propToIndex[key];\n        propertyNames[index] = key;\n    }\n    return _pureExpressionDef(64 /* TypePureObject */, checkIndex, propertyNames);\n}\nfunction _pureExpressionDef(flags, checkIndex, propertyNames) {\n    var bindings = new Array(propertyNames.length);\n    for (var i = 0; i < propertyNames.length; i++) {\n        var prop = propertyNames[i];\n        bindings[i] = {\n            flags: 8 /* 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        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: flags,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0,\n        matchedQueries: {},\n        matchedQueryIds: 0,\n        references: {},\n        ngContentIndex: -1,\n        childCount: 0, bindings: bindings,\n        bindingFlags: calcBindingFlags(bindings),\n        outputs: [],\n        element: null,\n        provider: null,\n        text: null,\n        query: null,\n        ngContent: null\n    };\n}\nfunction createPureExpression(view, def) {\n    return { value: undefined };\n}\nfunction checkAndUpdatePureExpressionInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var bindings = def.bindings;\n    var changed = false;\n    var bindLen = bindings.length;\n    if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0))\n        changed = true;\n    if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1))\n        changed = true;\n    if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2))\n        changed = true;\n    if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3))\n        changed = true;\n    if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4))\n        changed = true;\n    if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5))\n        changed = true;\n    if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6))\n        changed = true;\n    if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7))\n        changed = true;\n    if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8))\n        changed = true;\n    if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9))\n        changed = true;\n    if (changed) {\n        var data = asPureExpressionData(view, def.nodeIndex);\n        var value = void 0;\n        switch (def.flags & 201347067 /* Types */) {\n            case 32 /* TypePureArray */:\n                value = new Array(bindings.length);\n                if (bindLen > 0)\n                    value[0] = v0;\n                if (bindLen > 1)\n                    value[1] = v1;\n                if (bindLen > 2)\n                    value[2] = v2;\n                if (bindLen > 3)\n                    value[3] = v3;\n                if (bindLen > 4)\n                    value[4] = v4;\n                if (bindLen > 5)\n                    value[5] = v5;\n                if (bindLen > 6)\n                    value[6] = v6;\n                if (bindLen > 7)\n                    value[7] = v7;\n                if (bindLen > 8)\n                    value[8] = v8;\n                if (bindLen > 9)\n                    value[9] = v9;\n                break;\n            case 64 /* TypePureObject */:\n                value = {};\n                if (bindLen > 0)\n                    value[bindings[0].name] = v0;\n                if (bindLen > 1)\n                    value[bindings[1].name] = v1;\n                if (bindLen > 2)\n                    value[bindings[2].name] = v2;\n                if (bindLen > 3)\n                    value[bindings[3].name] = v3;\n                if (bindLen > 4)\n                    value[bindings[4].name] = v4;\n                if (bindLen > 5)\n                    value[bindings[5].name] = v5;\n                if (bindLen > 6)\n                    value[bindings[6].name] = v6;\n                if (bindLen > 7)\n                    value[bindings[7].name] = v7;\n                if (bindLen > 8)\n                    value[bindings[8].name] = v8;\n                if (bindLen > 9)\n                    value[bindings[9].name] = v9;\n                break;\n            case 128 /* TypePurePipe */:\n                var 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}\nfunction checkAndUpdatePureExpressionDynamic(view, def, values) {\n    var bindings = def.bindings;\n    var changed = false;\n    for (var 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        var data = asPureExpressionData(view, def.nodeIndex);\n        var value = void 0;\n        switch (def.flags & 201347067 /* Types */) {\n            case 32 /* TypePureArray */:\n                value = values;\n                break;\n            case 64 /* TypePureObject */:\n                value = {};\n                for (var i = 0; i < values.length; i++) {\n                    value[bindings[i].name] = values[i];\n                }\n                break;\n            case 128 /* TypePurePipe */:\n                var pipe = values[0];\n                var params = values.slice(1);\n                value = pipe.transform.apply(pipe, __spread(params));\n                break;\n        }\n        data.value = value;\n    }\n    return changed;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction textDef(checkIndex, ngContentIndex, staticText) {\n    var bindings = new Array(staticText.length - 1);\n    for (var i = 1; i < staticText.length; i++) {\n        bindings[i - 1] = {\n            flags: 8 /* TypeProperty */,\n            name: null,\n            ns: null,\n            nonMinifiedName: null,\n            securityContext: null,\n            suffix: staticText[i],\n        };\n    }\n    return {\n        // will bet set by the view definition\n        nodeIndex: -1,\n        parent: null,\n        renderParent: null,\n        bindingIndex: -1,\n        outputIndex: -1,\n        // regular values\n        checkIndex: checkIndex,\n        flags: 2 /* TypeText */,\n        childFlags: 0,\n        directChildFlags: 0,\n        childMatchedQueries: 0,\n        matchedQueries: {},\n        matchedQueryIds: 0,\n        references: {}, ngContentIndex: ngContentIndex,\n        childCount: 0, bindings: bindings,\n        bindingFlags: 8 /* TypeProperty */,\n        outputs: [],\n        element: null,\n        provider: null,\n        text: { prefix: staticText[0] },\n        query: null,\n        ngContent: null,\n    };\n}\nfunction createText(view, renderHost, def) {\n    var renderNode$$1;\n    var renderer = view.renderer;\n    renderNode$$1 = renderer.createText(def.text.prefix);\n    var parentEl = getParentRenderElement(view, renderHost, def);\n    if (parentEl) {\n        renderer.appendChild(parentEl, renderNode$$1);\n    }\n    return { renderText: renderNode$$1 };\n}\nfunction checkAndUpdateTextInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var changed = false;\n    var bindings = def.bindings;\n    var bindLen = bindings.length;\n    if (bindLen > 0 && checkAndUpdateBinding(view, def, 0, v0))\n        changed = true;\n    if (bindLen > 1 && checkAndUpdateBinding(view, def, 1, v1))\n        changed = true;\n    if (bindLen > 2 && checkAndUpdateBinding(view, def, 2, v2))\n        changed = true;\n    if (bindLen > 3 && checkAndUpdateBinding(view, def, 3, v3))\n        changed = true;\n    if (bindLen > 4 && checkAndUpdateBinding(view, def, 4, v4))\n        changed = true;\n    if (bindLen > 5 && checkAndUpdateBinding(view, def, 5, v5))\n        changed = true;\n    if (bindLen > 6 && checkAndUpdateBinding(view, def, 6, v6))\n        changed = true;\n    if (bindLen > 7 && checkAndUpdateBinding(view, def, 7, v7))\n        changed = true;\n    if (bindLen > 8 && checkAndUpdateBinding(view, def, 8, v8))\n        changed = true;\n    if (bindLen > 9 && checkAndUpdateBinding(view, def, 9, v9))\n        changed = true;\n    if (changed) {\n        var value = def.text.prefix;\n        if (bindLen > 0)\n            value += _addInterpolationPart(v0, bindings[0]);\n        if (bindLen > 1)\n            value += _addInterpolationPart(v1, bindings[1]);\n        if (bindLen > 2)\n            value += _addInterpolationPart(v2, bindings[2]);\n        if (bindLen > 3)\n            value += _addInterpolationPart(v3, bindings[3]);\n        if (bindLen > 4)\n            value += _addInterpolationPart(v4, bindings[4]);\n        if (bindLen > 5)\n            value += _addInterpolationPart(v5, bindings[5]);\n        if (bindLen > 6)\n            value += _addInterpolationPart(v6, bindings[6]);\n        if (bindLen > 7)\n            value += _addInterpolationPart(v7, bindings[7]);\n        if (bindLen > 8)\n            value += _addInterpolationPart(v8, bindings[8]);\n        if (bindLen > 9)\n            value += _addInterpolationPart(v9, bindings[9]);\n        var renderNode$$1 = asTextData(view, def.nodeIndex).renderText;\n        view.renderer.setValue(renderNode$$1, value);\n    }\n    return changed;\n}\nfunction checkAndUpdateTextDynamic(view, def, values) {\n    var bindings = def.bindings;\n    var changed = false;\n    for (var 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        var value = '';\n        for (var i = 0; i < values.length; i++) {\n            value = value + _addInterpolationPart(values[i], bindings[i]);\n        }\n        value = def.text.prefix + value;\n        var renderNode$$1 = asTextData(view, def.nodeIndex).renderText;\n        view.renderer.setValue(renderNode$$1, value);\n    }\n    return changed;\n}\nfunction _addInterpolationPart(value, binding) {\n    var valueStr = value != null ? value.toString() : '';\n    return valueStr + binding.suffix;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction viewDef(flags, nodes, updateDirectives, updateRenderer) {\n    // clone nodes and set auto calculated values\n    var viewBindingCount = 0;\n    var viewDisposableCount = 0;\n    var viewNodeFlags = 0;\n    var viewRootNodeFlags = 0;\n    var viewMatchedQueries = 0;\n    var currentParent = null;\n    var currentRenderParent = null;\n    var currentElementHasPublicProviders = false;\n    var currentElementHasPrivateProviders = false;\n    var lastRenderRootNode = null;\n    for (var i = 0; i < nodes.length; i++) {\n        var node = nodes[i];\n        node.nodeIndex = i;\n        node.parent = currentParent;\n        node.bindingIndex = viewBindingCount;\n        node.outputIndex = viewDisposableCount;\n        node.renderParent = currentRenderParent;\n        viewNodeFlags |= node.flags;\n        viewMatchedQueries |= node.matchedQueryIds;\n        if (node.element) {\n            var elDef = node.element;\n            elDef.publicProviders =\n                currentParent ? 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            if (node.element.template) {\n                viewMatchedQueries |= node.element.template.nodeMatchedQueries;\n            }\n        }\n        validateNode(currentParent, node, nodes.length);\n        viewBindingCount += node.bindings.length;\n        viewDisposableCount += node.outputs.length;\n        if (!currentRenderParent && (node.flags & 3 /* CatRenderNode */)) {\n            lastRenderRootNode = node;\n        }\n        if (node.flags & 20224 /* CatProvider */) {\n            if (!currentElementHasPublicProviders) {\n                currentElementHasPublicProviders = true;\n                // Use prototypical inheritance to not get O(n^2) complexity...\n                currentParent.element.publicProviders =\n                    Object.create(currentParent.element.publicProviders);\n                currentParent.element.allProviders = currentParent.element.publicProviders;\n            }\n            var isPrivateService = (node.flags & 8192 /* PrivateProvider */) !== 0;\n            var isComponent = (node.flags & 32768 /* Component */) !== 0;\n            if (!isPrivateService || isComponent) {\n                currentParent.element.publicProviders[tokenKey(node.provider.token)] = node;\n            }\n            else {\n                if (!currentElementHasPrivateProviders) {\n                    currentElementHasPrivateProviders = true;\n                    // Use prototypical inheritance to not get O(n^2) complexity...\n                    currentParent.element.allProviders =\n                        Object.create(currentParent.element.publicProviders);\n                }\n                currentParent.element.allProviders[tokenKey(node.provider.token)] = node;\n            }\n            if (isComponent) {\n                currentParent.element.componentProvider = node;\n            }\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        }\n        else {\n            viewRootNodeFlags |= node.flags;\n        }\n        if (node.childCount > 0) {\n            currentParent = node;\n            if (!isNgContainer(node)) {\n                currentRenderParent = node;\n            }\n        }\n        else {\n            // When the current node has no children, check if it is the last children of its parent.\n            // When it is, propagate the flags up.\n            // The loop is required because an element could be the last transitive children of several\n            // elements. We loop to either the root or the highest opened element (= with remaining\n            // children)\n            while (currentParent && i === currentParent.nodeIndex + currentParent.childCount) {\n                var newParent = currentParent.parent;\n                if (newParent) {\n                    newParent.childFlags |= currentParent.childFlags;\n                    newParent.childMatchedQueries |= currentParent.childMatchedQueries;\n                }\n                currentParent = newParent;\n                // We also need to update the render parent & account for ng-container\n                if (currentParent && isNgContainer(currentParent)) {\n                    currentRenderParent = currentParent.renderParent;\n                }\n                else {\n                    currentRenderParent = currentParent;\n                }\n            }\n        }\n    }\n    var handleEvent = function (view, nodeIndex, eventName, event) {\n        return nodes[nodeIndex].element.handleEvent(view, eventName, event);\n    };\n    return {\n        // Will be filled later...\n        factory: null,\n        nodeFlags: viewNodeFlags,\n        rootNodeFlags: viewRootNodeFlags,\n        nodeMatchedQueries: viewMatchedQueries, flags: flags,\n        nodes: nodes,\n        updateDirectives: updateDirectives || NOOP,\n        updateRenderer: updateRenderer || NOOP, handleEvent: handleEvent,\n        bindingCount: viewBindingCount,\n        outputCount: viewDisposableCount, lastRenderRootNode: lastRenderRootNode\n    };\n}\nfunction isNgContainer(node) {\n    return (node.flags & 1 /* TypeElement */) !== 0 && node.element.name === null;\n}\nfunction validateNode(parent, node, nodeCount) {\n    var 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 & 16777216 /* EmbeddedViews */) {\n            throw new Error(\"Illegal State: Last root node of a template can't have embedded views, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n    if (node.flags & 20224 /* CatProvider */) {\n        var parentFlags = parent ? parent.flags : 0;\n        if ((parentFlags & 1 /* TypeElement */) === 0) {\n            throw new Error(\"Illegal State: StaticProvider/Directive nodes need to be children of elements or anchors, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n    if (node.query) {\n        if (node.flags & 67108864 /* TypeContentQuery */ &&\n            (!parent || (parent.flags & 16384 /* TypeDirective */) === 0)) {\n            throw new Error(\"Illegal State: Content Query nodes need to be children of directives, at index \" + node.nodeIndex + \"!\");\n        }\n        if (node.flags & 134217728 /* TypeViewQuery */ && parent) {\n            throw new Error(\"Illegal State: View Query nodes have to be top level nodes, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n    if (node.childCount) {\n        var parentEnd = parent ? parent.nodeIndex + parent.childCount : nodeCount - 1;\n        if (node.nodeIndex <= parentEnd && node.nodeIndex + node.childCount > parentEnd) {\n            throw new Error(\"Illegal State: childCount of node leads outside of parent, at index \" + node.nodeIndex + \"!\");\n        }\n    }\n}\nfunction createEmbeddedView(parent, anchorDef$$1, viewDef, context) {\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    var view = createView(parent.root, parent.renderer, parent, anchorDef$$1, viewDef);\n    initView(view, parent.component, context);\n    createViewNodes(view);\n    return view;\n}\nfunction createRootView(root, def, context) {\n    var view = createView(root, root.renderer, null, null, def);\n    initView(view, context, context);\n    createViewNodes(view);\n    return view;\n}\nfunction createComponentView(parentView, nodeDef, viewDef, hostElement) {\n    var rendererType = nodeDef.element.componentRendererType;\n    var compRenderer;\n    if (!rendererType) {\n        compRenderer = parentView.root.renderer;\n    }\n    else {\n        compRenderer = parentView.root.rendererFactory.createRenderer(hostElement, rendererType);\n    }\n    return createView(parentView.root, compRenderer, parentView, nodeDef.element.componentProvider, viewDef);\n}\nfunction createView(root, renderer, parent, parentNodeDef, def) {\n    var nodes = new Array(def.nodes.length);\n    var disposables = def.outputCount ? new Array(def.outputCount) : null;\n    var view = {\n        def: def,\n        parent: parent,\n        viewContainerParent: null, parentNodeDef: parentNodeDef,\n        context: null,\n        component: null, nodes: nodes,\n        state: 13 /* CatInit */, root: root, renderer: renderer,\n        oldValues: new Array(def.bindingCount), disposables: disposables,\n        initIndex: -1\n    };\n    return view;\n}\nfunction initView(view, component, context) {\n    view.component = component;\n    view.context = context;\n}\nfunction createViewNodes(view) {\n    var renderHost;\n    if (isComponentView(view)) {\n        var hostDef = view.parentNodeDef;\n        renderHost = asElementData(view.parent, hostDef.parent.nodeIndex).renderElement;\n    }\n    var def = view.def;\n    var nodes = view.nodes;\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        Services.setCurrentNode(view, i);\n        var nodeData = void 0;\n        switch (nodeDef.flags & 201347067 /* Types */) {\n            case 1 /* TypeElement */:\n                var el = createElement(view, renderHost, nodeDef);\n                var componentView = undefined;\n                if (nodeDef.flags & 33554432 /* ComponentView */) {\n                    var compViewDef = resolveDefinition(nodeDef.element.componentView);\n                    componentView = Services.createComponentView(view, nodeDef, compViewDef, el);\n                }\n                listenToElementOutputs(view, componentView, nodeDef, el);\n                nodeData = {\n                    renderElement: el,\n                    componentView: componentView,\n                    viewContainer: null,\n                    template: nodeDef.element.template ? createTemplateData(view, nodeDef) : undefined\n                };\n                if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n                    nodeData.viewContainer = createViewContainerData(view, nodeDef, nodeData);\n                }\n                break;\n            case 2 /* TypeText */:\n                nodeData = createText(view, renderHost, nodeDef);\n                break;\n            case 512 /* TypeClassProvider */:\n            case 1024 /* TypeFactoryProvider */:\n            case 2048 /* TypeUseExistingProvider */:\n            case 256 /* TypeValueProvider */: {\n                nodeData = nodes[i];\n                if (!nodeData && !(nodeDef.flags & 4096 /* LazyProvider */)) {\n                    var instance = createProviderInstance(view, nodeDef);\n                    nodeData = { instance: instance };\n                }\n                break;\n            }\n            case 16 /* TypePipe */: {\n                var instance = createPipeInstance(view, nodeDef);\n                nodeData = { instance: instance };\n                break;\n            }\n            case 16384 /* TypeDirective */: {\n                nodeData = nodes[i];\n                if (!nodeData) {\n                    var instance = createDirectiveInstance(view, nodeDef);\n                    nodeData = { instance: instance };\n                }\n                if (nodeDef.flags & 32768 /* Component */) {\n                    var compView = asElementData(view, nodeDef.parent.nodeIndex).componentView;\n                    initView(compView, nodeData.instance, nodeData.instance);\n                }\n                break;\n            }\n            case 32 /* TypePureArray */:\n            case 64 /* TypePureObject */:\n            case 128 /* TypePurePipe */:\n                nodeData = createPureExpression(view, nodeDef);\n                break;\n            case 67108864 /* TypeContentQuery */:\n            case 134217728 /* TypeViewQuery */:\n                nodeData = createQuery();\n                break;\n            case 8 /* 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    // fill static content and view queries\n    execQueriesAction(view, 67108864 /* TypeContentQuery */ | 134217728 /* TypeViewQuery */, 268435456 /* StaticQuery */, 0 /* CheckAndUpdate */);\n}\nfunction checkNoChangesView(view) {\n    markProjectedViewsForCheck(view);\n    Services.updateDirectives(view, 1 /* CheckNoChanges */);\n    execEmbeddedViewsAction(view, ViewAction.CheckNoChanges);\n    Services.updateRenderer(view, 1 /* 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 &= ~(64 /* CheckProjectedViews */ | 32 /* CheckProjectedView */);\n}\nfunction checkAndUpdateView(view) {\n    if (view.state & 1 /* BeforeFirstCheck */) {\n        view.state &= ~1 /* BeforeFirstCheck */;\n        view.state |= 2 /* FirstCheck */;\n    }\n    else {\n        view.state &= ~2 /* FirstCheck */;\n    }\n    shiftInitState(view, 0 /* InitState_BeforeInit */, 256 /* InitState_CallingOnInit */);\n    markProjectedViewsForCheck(view);\n    Services.updateDirectives(view, 0 /* CheckAndUpdate */);\n    execEmbeddedViewsAction(view, ViewAction.CheckAndUpdate);\n    execQueriesAction(view, 67108864 /* TypeContentQuery */, 536870912 /* DynamicQuery */, 0 /* CheckAndUpdate */);\n    var callInit = shiftInitState(view, 256 /* InitState_CallingOnInit */, 512 /* InitState_CallingAfterContentInit */);\n    callLifecycleHooksChildrenFirst(view, 2097152 /* AfterContentChecked */ | (callInit ? 1048576 /* AfterContentInit */ : 0));\n    Services.updateRenderer(view, 0 /* CheckAndUpdate */);\n    execComponentViewsAction(view, ViewAction.CheckAndUpdate);\n    execQueriesAction(view, 134217728 /* TypeViewQuery */, 536870912 /* DynamicQuery */, 0 /* CheckAndUpdate */);\n    callInit = shiftInitState(view, 512 /* InitState_CallingAfterContentInit */, 768 /* InitState_CallingAfterViewInit */);\n    callLifecycleHooksChildrenFirst(view, 8388608 /* AfterViewChecked */ | (callInit ? 4194304 /* AfterViewInit */ : 0));\n    if (view.def.flags & 2 /* OnPush */) {\n        view.state &= ~8 /* ChecksEnabled */;\n    }\n    view.state &= ~(64 /* CheckProjectedViews */ | 32 /* CheckProjectedView */);\n    shiftInitState(view, 768 /* InitState_CallingAfterViewInit */, 1024 /* InitState_AfterInit */);\n}\nfunction checkAndUpdateNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    if (argStyle === 0 /* Inline */) {\n        return checkAndUpdateNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    }\n    else {\n        return checkAndUpdateNodeDynamic(view, nodeDef, v0);\n    }\n}\nfunction markProjectedViewsForCheck(view) {\n    var def = view.def;\n    if (!(def.nodeFlags & 4 /* ProjectedTemplate */)) {\n        return;\n    }\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        if (nodeDef.flags & 4 /* ProjectedTemplate */) {\n            var projectedViews = asElementData(view, i).template._projectedViews;\n            if (projectedViews) {\n                for (var i_1 = 0; i_1 < projectedViews.length; i_1++) {\n                    var projectedView = projectedViews[i_1];\n                    projectedView.state |= 32 /* CheckProjectedView */;\n                    markParentViewsForCheckProjectedViews(projectedView, view);\n                }\n            }\n        }\n        else if ((nodeDef.childFlags & 4 /* 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}\nfunction checkAndUpdateNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    switch (nodeDef.flags & 201347067 /* Types */) {\n        case 1 /* TypeElement */:\n            return checkAndUpdateElementInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        case 2 /* TypeText */:\n            return checkAndUpdateTextInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        case 16384 /* TypeDirective */:\n            return checkAndUpdateDirectiveInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        case 32 /* TypePureArray */:\n        case 64 /* TypePureObject */:\n        case 128 /* TypePurePipe */:\n            return checkAndUpdatePureExpressionInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n        default:\n            throw 'unreachable';\n    }\n}\nfunction checkAndUpdateNodeDynamic(view, nodeDef, values) {\n    switch (nodeDef.flags & 201347067 /* Types */) {\n        case 1 /* TypeElement */:\n            return checkAndUpdateElementDynamic(view, nodeDef, values);\n        case 2 /* TypeText */:\n            return checkAndUpdateTextDynamic(view, nodeDef, values);\n        case 16384 /* TypeDirective */:\n            return checkAndUpdateDirectiveDynamic(view, nodeDef, values);\n        case 32 /* TypePureArray */:\n        case 64 /* TypePureObject */:\n        case 128 /* TypePurePipe */:\n            return checkAndUpdatePureExpressionDynamic(view, nodeDef, values);\n        default:\n            throw 'unreachable';\n    }\n}\nfunction checkNoChangesNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    if (argStyle === 0 /* Inline */) {\n        checkNoChangesNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    }\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}\nfunction checkNoChangesNodeInline(view, nodeDef, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var bindLen = nodeDef.bindings.length;\n    if (bindLen > 0)\n        checkBindingNoChanges(view, nodeDef, 0, v0);\n    if (bindLen > 1)\n        checkBindingNoChanges(view, nodeDef, 1, v1);\n    if (bindLen > 2)\n        checkBindingNoChanges(view, nodeDef, 2, v2);\n    if (bindLen > 3)\n        checkBindingNoChanges(view, nodeDef, 3, v3);\n    if (bindLen > 4)\n        checkBindingNoChanges(view, nodeDef, 4, v4);\n    if (bindLen > 5)\n        checkBindingNoChanges(view, nodeDef, 5, v5);\n    if (bindLen > 6)\n        checkBindingNoChanges(view, nodeDef, 6, v6);\n    if (bindLen > 7)\n        checkBindingNoChanges(view, nodeDef, 7, v7);\n    if (bindLen > 8)\n        checkBindingNoChanges(view, nodeDef, 8, v8);\n    if (bindLen > 9)\n        checkBindingNoChanges(view, nodeDef, 9, v9);\n}\nfunction checkNoChangesNodeDynamic(view, nodeDef, values) {\n    for (var i = 0; i < values.length; i++) {\n        checkBindingNoChanges(view, nodeDef, i, values[i]);\n    }\n}\n/**\n * Workaround https://github.com/angular/tsickle/issues/497\n * @suppress {misplacedTypeAnnotation}\n */\nfunction checkNoChangesQuery(view, nodeDef) {\n    var queryList = asQueryList(view, nodeDef.nodeIndex);\n    if (queryList.dirty) {\n        throw expressionChangedAfterItHasBeenCheckedError(Services.createDebugContext(view, nodeDef.nodeIndex), \"Query \" + nodeDef.query.id + \" not dirty\", \"Query \" + nodeDef.query.id + \" dirty\", (view.state & 1 /* BeforeFirstCheck */) !== 0);\n    }\n}\nfunction destroyView(view) {\n    if (view.state & 128 /* Destroyed */) {\n        return;\n    }\n    execEmbeddedViewsAction(view, ViewAction.Destroy);\n    execComponentViewsAction(view, ViewAction.Destroy);\n    callLifecycleHooksChildrenFirst(view, 131072 /* OnDestroy */);\n    if (view.disposables) {\n        for (var 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 |= 128 /* Destroyed */;\n}\nfunction destroyViewNodes(view) {\n    var len = view.def.nodes.length;\n    for (var i = 0; i < len; i++) {\n        var def = view.def.nodes[i];\n        if (def.flags & 1 /* TypeElement */) {\n            view.renderer.destroyNode(asElementData(view, i).renderElement);\n        }\n        else if (def.flags & 2 /* TypeText */) {\n            view.renderer.destroyNode(asTextData(view, i).renderText);\n        }\n        else if (def.flags & 67108864 /* TypeContentQuery */ || def.flags & 134217728 /* TypeViewQuery */) {\n            asQueryList(view, i).destroy();\n        }\n    }\n}\nvar ViewAction;\n(function (ViewAction) {\n    ViewAction[ViewAction[\"CreateViewNodes\"] = 0] = \"CreateViewNodes\";\n    ViewAction[ViewAction[\"CheckNoChanges\"] = 1] = \"CheckNoChanges\";\n    ViewAction[ViewAction[\"CheckNoChangesProjectedViews\"] = 2] = \"CheckNoChangesProjectedViews\";\n    ViewAction[ViewAction[\"CheckAndUpdate\"] = 3] = \"CheckAndUpdate\";\n    ViewAction[ViewAction[\"CheckAndUpdateProjectedViews\"] = 4] = \"CheckAndUpdateProjectedViews\";\n    ViewAction[ViewAction[\"Destroy\"] = 5] = \"Destroy\";\n})(ViewAction || (ViewAction = {}));\nfunction execComponentViewsAction(view, action) {\n    var def = view.def;\n    if (!(def.nodeFlags & 33554432 /* ComponentView */)) {\n        return;\n    }\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        if (nodeDef.flags & 33554432 /* ComponentView */) {\n            // a leaf\n            callViewAction(asElementData(view, i).componentView, action);\n        }\n        else if ((nodeDef.childFlags & 33554432 /* 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}\nfunction execEmbeddedViewsAction(view, action) {\n    var def = view.def;\n    if (!(def.nodeFlags & 16777216 /* EmbeddedViews */)) {\n        return;\n    }\n    for (var i = 0; i < def.nodes.length; i++) {\n        var nodeDef = def.nodes[i];\n        if (nodeDef.flags & 16777216 /* EmbeddedViews */) {\n            // a leaf\n            var embeddedViews = asElementData(view, i).viewContainer._embeddedViews;\n            for (var k = 0; k < embeddedViews.length; k++) {\n                callViewAction(embeddedViews[k], action);\n            }\n        }\n        else if ((nodeDef.childFlags & 16777216 /* 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}\nfunction callViewAction(view, action) {\n    var viewState = view.state;\n    switch (action) {\n        case ViewAction.CheckNoChanges:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if ((viewState & 12 /* CatDetectChanges */) === 12 /* CatDetectChanges */) {\n                    checkNoChangesView(view);\n                }\n                else if (viewState & 64 /* CheckProjectedViews */) {\n                    execProjectedViewsAction(view, ViewAction.CheckNoChangesProjectedViews);\n                }\n            }\n            break;\n        case ViewAction.CheckNoChangesProjectedViews:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if (viewState & 32 /* CheckProjectedView */) {\n                    checkNoChangesView(view);\n                }\n                else if (viewState & 64 /* CheckProjectedViews */) {\n                    execProjectedViewsAction(view, action);\n                }\n            }\n            break;\n        case ViewAction.CheckAndUpdate:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if ((viewState & 12 /* CatDetectChanges */) === 12 /* CatDetectChanges */) {\n                    checkAndUpdateView(view);\n                }\n                else if (viewState & 64 /* CheckProjectedViews */) {\n                    execProjectedViewsAction(view, ViewAction.CheckAndUpdateProjectedViews);\n                }\n            }\n            break;\n        case ViewAction.CheckAndUpdateProjectedViews:\n            if ((viewState & 128 /* Destroyed */) === 0) {\n                if (viewState & 32 /* CheckProjectedView */) {\n                    checkAndUpdateView(view);\n                }\n                else if (viewState & 64 /* 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}\nfunction execProjectedViewsAction(view, action) {\n    execEmbeddedViewsAction(view, action);\n    execComponentViewsAction(view, action);\n}\nfunction execQueriesAction(view, queryFlags, staticDynamicQueryFlag, checkType) {\n    if (!(view.def.nodeFlags & queryFlags) || !(view.def.nodeFlags & staticDynamicQueryFlag)) {\n        return;\n    }\n    var nodeCount = view.def.nodes.length;\n    for (var i = 0; i < nodeCount; i++) {\n        var nodeDef = view.def.nodes[i];\n        if ((nodeDef.flags & queryFlags) && (nodeDef.flags & staticDynamicQueryFlag)) {\n            Services.setCurrentNode(view, nodeDef.nodeIndex);\n            switch (checkType) {\n                case 0 /* CheckAndUpdate */:\n                    checkAndUpdateQuery(view, nodeDef);\n                    break;\n                case 1 /* 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/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar initialized = false;\nfunction initServicesIfNeeded() {\n    if (initialized) {\n        return;\n    }\n    initialized = true;\n    var 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.overrideComponentView = services.overrideComponentView;\n    Services.clearOverrides = services.clearOverrides;\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}\nfunction createProdServices() {\n    return {\n        setCurrentNode: function () { },\n        createRootView: createProdRootView,\n        createEmbeddedView: createEmbeddedView,\n        createComponentView: createComponentView,\n        createNgModuleRef: createNgModuleRef,\n        overrideProvider: NOOP,\n        overrideComponentView: NOOP,\n        clearOverrides: NOOP,\n        checkAndUpdateView: checkAndUpdateView,\n        checkNoChangesView: checkNoChangesView,\n        destroyView: destroyView,\n        createDebugContext: function (view, nodeIndex) { return new DebugContext_(view, nodeIndex); },\n        handleEvent: function (view, nodeIndex, eventName, event) {\n            return view.def.handleEvent(view, nodeIndex, eventName, event);\n        },\n        updateDirectives: function (view, checkType) { return view.def.updateDirectives(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :\n            prodCheckNoChangesNode, view); },\n        updateRenderer: function (view, checkType) { return view.def.updateRenderer(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :\n            prodCheckNoChangesNode, view); },\n    };\n}\nfunction createDebugServices() {\n    return {\n        setCurrentNode: debugSetCurrentNode,\n        createRootView: debugCreateRootView,\n        createEmbeddedView: debugCreateEmbeddedView,\n        createComponentView: debugCreateComponentView,\n        createNgModuleRef: debugCreateNgModuleRef,\n        overrideProvider: debugOverrideProvider,\n        overrideComponentView: debugOverrideComponentView,\n        clearOverrides: debugClearOverrides,\n        checkAndUpdateView: debugCheckAndUpdateView,\n        checkNoChangesView: debugCheckNoChangesView,\n        destroyView: debugDestroyView,\n        createDebugContext: function (view, nodeIndex) { return new DebugContext_(view, nodeIndex); },\n        handleEvent: debugHandleEvent,\n        updateDirectives: debugUpdateDirectives,\n        updateRenderer: debugUpdateRenderer,\n    };\n}\nfunction createProdRootView(elInjector, projectableNodes, rootSelectorOrNode, def, ngModule, context) {\n    var rendererFactory = ngModule.injector.get(RendererFactory2);\n    return createRootView(createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode), def, context);\n}\nfunction debugCreateRootView(elInjector, projectableNodes, rootSelectorOrNode, def, ngModule, context) {\n    var rendererFactory = ngModule.injector.get(RendererFactory2);\n    var root = createRootData(elInjector, ngModule, new DebugRendererFactory2(rendererFactory), projectableNodes, rootSelectorOrNode);\n    var defWithOverride = applyProviderOverridesToView(def);\n    return callWithDebugContext(DebugAction.create, createRootView, null, [root, defWithOverride, context]);\n}\nfunction createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode) {\n    var sanitizer = ngModule.injector.get(Sanitizer);\n    var errorHandler = ngModule.injector.get(ErrorHandler);\n    var renderer = rendererFactory.createRenderer(null, null);\n    return {\n        ngModule: ngModule,\n        injector: elInjector, projectableNodes: projectableNodes,\n        selectorOrNode: rootSelectorOrNode, sanitizer: sanitizer, rendererFactory: rendererFactory, renderer: renderer, errorHandler: errorHandler\n    };\n}\nfunction debugCreateEmbeddedView(parentView, anchorDef, viewDef$$1, context) {\n    var defWithOverride = applyProviderOverridesToView(viewDef$$1);\n    return callWithDebugContext(DebugAction.create, createEmbeddedView, null, [parentView, anchorDef, defWithOverride, context]);\n}\nfunction debugCreateComponentView(parentView, nodeDef, viewDef$$1, hostElement) {\n    var overrideComponentView = viewDefOverrides.get(nodeDef.element.componentProvider.provider.token);\n    if (overrideComponentView) {\n        viewDef$$1 = overrideComponentView;\n    }\n    else {\n        viewDef$$1 = applyProviderOverridesToView(viewDef$$1);\n    }\n    return callWithDebugContext(DebugAction.create, createComponentView, null, [parentView, nodeDef, viewDef$$1, hostElement]);\n}\nfunction debugCreateNgModuleRef(moduleType, parentInjector, bootstrapComponents, def) {\n    var defWithOverride = applyProviderOverridesToNgModule(def);\n    return createNgModuleRef(moduleType, parentInjector, bootstrapComponents, defWithOverride);\n}\nvar providerOverrides = new Map();\nvar providerOverridesWithScope = new Map();\nvar viewDefOverrides = new Map();\nfunction debugOverrideProvider(override) {\n    providerOverrides.set(override.token, override);\n    if (typeof override.token === 'function' && override.token.ngInjectableDef &&\n        typeof override.token.ngInjectableDef.providedIn === 'function') {\n        providerOverridesWithScope.set(override.token, override);\n    }\n}\nfunction debugOverrideComponentView(comp, compFactory) {\n    var hostViewDef = resolveDefinition(getComponentViewDefinitionFactory(compFactory));\n    var compViewDef = resolveDefinition(hostViewDef.nodes[0].element.componentView);\n    viewDefOverrides.set(comp, compViewDef);\n}\nfunction debugClearOverrides() {\n    providerOverrides.clear();\n    providerOverridesWithScope.clear();\n    viewDefOverrides.clear();\n}\n// Notes about the algorithm:\n// 1) Locate the providers of an element and check if one of them was overwritten\n// 2) Change the providers of that element\n//\n// We only create new datastructures if we need to, to keep perf impact\n// reasonable.\nfunction applyProviderOverridesToView(def) {\n    if (providerOverrides.size === 0) {\n        return def;\n    }\n    var 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 = def.factory(function () { return NOOP; });\n    for (var i = 0; i < elementIndicesWithOverwrittenProviders.length; i++) {\n        applyProviderOverridesToElement(def, elementIndicesWithOverwrittenProviders[i]);\n    }\n    return def;\n    function findElementIndicesWithOverwrittenProviders(def) {\n        var elIndicesWithOverwrittenProviders = [];\n        var lastElementDef = null;\n        for (var i = 0; i < def.nodes.length; i++) {\n            var nodeDef = def.nodes[i];\n            if (nodeDef.flags & 1 /* TypeElement */) {\n                lastElementDef = nodeDef;\n            }\n            if (lastElementDef && nodeDef.flags & 3840 /* CatProviderNoDirective */ &&\n                providerOverrides.has(nodeDef.provider.token)) {\n                elIndicesWithOverwrittenProviders.push(lastElementDef.nodeIndex);\n                lastElementDef = null;\n            }\n        }\n        return elIndicesWithOverwrittenProviders;\n    }\n    function applyProviderOverridesToElement(viewDef$$1, elIndex) {\n        for (var i = elIndex + 1; i < viewDef$$1.nodes.length; i++) {\n            var nodeDef = viewDef$$1.nodes[i];\n            if (nodeDef.flags & 1 /* TypeElement */) {\n                // stop at the next element\n                return;\n            }\n            if (nodeDef.flags & 3840 /* CatProviderNoDirective */) {\n                var provider = nodeDef.provider;\n                var override = providerOverrides.get(provider.token);\n                if (override) {\n                    nodeDef.flags = (nodeDef.flags & ~3840 /* CatProviderNoDirective */) | override.flags;\n                    provider.deps = splitDepsDsl(override.deps);\n                    provider.value = override.value;\n                }\n            }\n        }\n    }\n}\n// Notes about the algorithm:\n// We only create new datastructures if we need to, to keep perf impact\n// reasonable.\nfunction applyProviderOverridesToNgModule(def) {\n    var _a = calcHasOverrides(def), hasOverrides = _a.hasOverrides, hasDeprecatedOverrides = _a.hasDeprecatedOverrides;\n    if (!hasOverrides) {\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 = def.factory(function () { return NOOP; });\n    applyProviderOverrides(def);\n    return def;\n    function calcHasOverrides(def) {\n        var hasOverrides = false;\n        var hasDeprecatedOverrides = false;\n        if (providerOverrides.size === 0) {\n            return { hasOverrides: hasOverrides, hasDeprecatedOverrides: hasDeprecatedOverrides };\n        }\n        def.providers.forEach(function (node) {\n            var override = providerOverrides.get(node.token);\n            if ((node.flags & 3840 /* CatProviderNoDirective */) && override) {\n                hasOverrides = true;\n                hasDeprecatedOverrides = hasDeprecatedOverrides || override.deprecatedBehavior;\n            }\n        });\n        def.modules.forEach(function (module) {\n            providerOverridesWithScope.forEach(function (override, token) {\n                if (token.ngInjectableDef.providedIn === module) {\n                    hasOverrides = true;\n                    hasDeprecatedOverrides = hasDeprecatedOverrides || override.deprecatedBehavior;\n                }\n            });\n        });\n        return { hasOverrides: hasOverrides, hasDeprecatedOverrides: hasDeprecatedOverrides };\n    }\n    function applyProviderOverrides(def) {\n        for (var i = 0; i < def.providers.length; i++) {\n            var provider = def.providers[i];\n            if (hasDeprecatedOverrides) {\n                // We had a bug where me made\n                // all providers lazy. Keep this logic behind a flag\n                // for migrating existing users.\n                provider.flags |= 4096 /* LazyProvider */;\n            }\n            var override = providerOverrides.get(provider.token);\n            if (override) {\n                provider.flags = (provider.flags & ~3840 /* CatProviderNoDirective */) | override.flags;\n                provider.deps = splitDepsDsl(override.deps);\n                provider.value = override.value;\n            }\n        }\n        if (providerOverridesWithScope.size > 0) {\n            var moduleSet_1 = new Set(def.modules);\n            providerOverridesWithScope.forEach(function (override, token) {\n                if (moduleSet_1.has(token.ngInjectableDef.providedIn)) {\n                    var provider = {\n                        token: token,\n                        flags: override.flags | (hasDeprecatedOverrides ? 4096 /* LazyProvider */ : 0 /* None */),\n                        deps: splitDepsDsl(override.deps),\n                        value: override.value,\n                        index: def.providers.length,\n                    };\n                    def.providers.push(provider);\n                    def.providersByKey[tokenKey(token)] = provider;\n                }\n            });\n        }\n    }\n}\nfunction prodCheckAndUpdateNode(view, checkIndex, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var nodeDef = view.def.nodes[checkIndex];\n    checkAndUpdateNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    return (nodeDef.flags & 224 /* CatPureExpression */) ?\n        asPureExpressionData(view, checkIndex).value :\n        undefined;\n}\nfunction prodCheckNoChangesNode(view, checkIndex, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {\n    var nodeDef = view.def.nodes[checkIndex];\n    checkNoChangesNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);\n    return (nodeDef.flags & 224 /* CatPureExpression */) ?\n        asPureExpressionData(view, checkIndex).value :\n        undefined;\n}\nfunction debugCheckAndUpdateView(view) {\n    return callWithDebugContext(DebugAction.detectChanges, checkAndUpdateView, null, [view]);\n}\nfunction debugCheckNoChangesView(view) {\n    return callWithDebugContext(DebugAction.checkNoChanges, checkNoChangesView, null, [view]);\n}\nfunction debugDestroyView(view) {\n    return callWithDebugContext(DebugAction.destroy, destroyView, null, [view]);\n}\nvar DebugAction;\n(function (DebugAction) {\n    DebugAction[DebugAction[\"create\"] = 0] = \"create\";\n    DebugAction[DebugAction[\"detectChanges\"] = 1] = \"detectChanges\";\n    DebugAction[DebugAction[\"checkNoChanges\"] = 2] = \"checkNoChanges\";\n    DebugAction[DebugAction[\"destroy\"] = 3] = \"destroy\";\n    DebugAction[DebugAction[\"handleEvent\"] = 4] = \"handleEvent\";\n})(DebugAction || (DebugAction = {}));\nvar _currentAction;\nvar _currentView;\nvar _currentNodeIndex;\nfunction debugSetCurrentNode(view, nodeIndex) {\n    _currentView = view;\n    _currentNodeIndex = nodeIndex;\n}\nfunction debugHandleEvent(view, nodeIndex, eventName, event) {\n    debugSetCurrentNode(view, nodeIndex);\n    return callWithDebugContext(DebugAction.handleEvent, view.def.handleEvent, null, [view, nodeIndex, eventName, event]);\n}\nfunction debugUpdateDirectives(view, checkType) {\n    if (view.state & 128 /* Destroyed */) {\n        throw viewDestroyedError(DebugAction[_currentAction]);\n    }\n    debugSetCurrentNode(view, nextDirectiveWithBinding(view, 0));\n    return view.def.updateDirectives(debugCheckDirectivesFn, view);\n    function debugCheckDirectivesFn(view, nodeIndex, argStyle) {\n        var values = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            values[_i - 3] = arguments[_i];\n        }\n        var nodeDef = view.def.nodes[nodeIndex];\n        if (checkType === 0 /* CheckAndUpdate */) {\n            debugCheckAndUpdateNode(view, nodeDef, argStyle, values);\n        }\n        else {\n            debugCheckNoChangesNode(view, nodeDef, argStyle, values);\n        }\n        if (nodeDef.flags & 16384 /* TypeDirective */) {\n            debugSetCurrentNode(view, nextDirectiveWithBinding(view, nodeIndex));\n        }\n        return (nodeDef.flags & 224 /* CatPureExpression */) ?\n            asPureExpressionData(view, nodeDef.nodeIndex).value :\n            undefined;\n    }\n}\nfunction debugUpdateRenderer(view, checkType) {\n    if (view.state & 128 /* Destroyed */) {\n        throw viewDestroyedError(DebugAction[_currentAction]);\n    }\n    debugSetCurrentNode(view, nextRenderNodeWithBinding(view, 0));\n    return view.def.updateRenderer(debugCheckRenderNodeFn, view);\n    function debugCheckRenderNodeFn(view, nodeIndex, argStyle) {\n        var values = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            values[_i - 3] = arguments[_i];\n        }\n        var nodeDef = view.def.nodes[nodeIndex];\n        if (checkType === 0 /* CheckAndUpdate */) {\n            debugCheckAndUpdateNode(view, nodeDef, argStyle, values);\n        }\n        else {\n            debugCheckNoChangesNode(view, nodeDef, argStyle, values);\n        }\n        if (nodeDef.flags & 3 /* CatRenderNode */) {\n            debugSetCurrentNode(view, nextRenderNodeWithBinding(view, nodeIndex));\n        }\n        return (nodeDef.flags & 224 /* CatPureExpression */) ?\n            asPureExpressionData(view, nodeDef.nodeIndex).value :\n            undefined;\n    }\n}\nfunction debugCheckAndUpdateNode(view, nodeDef, argStyle, givenValues) {\n    var changed = checkAndUpdateNode.apply(void 0, __spread([view, nodeDef, argStyle], givenValues));\n    if (changed) {\n        var values = argStyle === 1 /* Dynamic */ ? givenValues[0] : givenValues;\n        if (nodeDef.flags & 16384 /* TypeDirective */) {\n            var bindingValues = {};\n            for (var i = 0; i < nodeDef.bindings.length; i++) {\n                var binding = nodeDef.bindings[i];\n                var value = values[i];\n                if (binding.flags & 8 /* TypeProperty */) {\n                    bindingValues[normalizeDebugBindingName(binding.nonMinifiedName)] =\n                        normalizeDebugBindingValue(value);\n                }\n            }\n            var elDef = nodeDef.parent;\n            var el = asElementData(view, elDef.nodeIndex).renderElement;\n            if (!elDef.element.name) {\n                // a comment.\n                view.renderer.setValue(el, \"bindings=\" + JSON.stringify(bindingValues, null, 2));\n            }\n            else {\n                // a regular element.\n                for (var attr in bindingValues) {\n                    var value = bindingValues[attr];\n                    if (value != null) {\n                        view.renderer.setAttribute(el, attr, value);\n                    }\n                    else {\n                        view.renderer.removeAttribute(el, attr);\n                    }\n                }\n            }\n        }\n    }\n}\nfunction debugCheckNoChangesNode(view, nodeDef, argStyle, values) {\n    checkNoChangesNode.apply(void 0, __spread([view, nodeDef, argStyle], values));\n}\nfunction normalizeDebugBindingName(name) {\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}\nvar CAMEL_CASE_REGEXP = /([A-Z])/g;\nfunction camelCaseToDashCase(input) {\n    return input.replace(CAMEL_CASE_REGEXP, function () {\n        var m = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            m[_i] = arguments[_i];\n        }\n        return '-' + m[1].toLowerCase();\n    });\n}\nfunction normalizeDebugBindingValue(value) {\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    }\n    catch (e) {\n        return '[ERROR] Exception while trying to serialize the value';\n    }\n}\nfunction nextDirectiveWithBinding(view, nodeIndex) {\n    for (var i = nodeIndex; i < view.def.nodes.length; i++) {\n        var nodeDef = view.def.nodes[i];\n        if (nodeDef.flags & 16384 /* TypeDirective */ && nodeDef.bindings && nodeDef.bindings.length) {\n            return i;\n        }\n    }\n    return null;\n}\nfunction nextRenderNodeWithBinding(view, nodeIndex) {\n    for (var i = nodeIndex; i < view.def.nodes.length; i++) {\n        var nodeDef = view.def.nodes[i];\n        if ((nodeDef.flags & 3 /* CatRenderNode */) && nodeDef.bindings && nodeDef.bindings.length) {\n            return i;\n        }\n    }\n    return null;\n}\nvar DebugContext_ = /** @class */ (function () {\n    function DebugContext_(view, nodeIndex) {\n        this.view = view;\n        this.nodeIndex = nodeIndex;\n        if (nodeIndex == null) {\n            this.nodeIndex = nodeIndex = 0;\n        }\n        this.nodeDef = view.def.nodes[nodeIndex];\n        var elDef = this.nodeDef;\n        var elView = view;\n        while (elDef && (elDef.flags & 1 /* 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    Object.defineProperty(DebugContext_.prototype, \"elOrCompView\", {\n        get: function () {\n            // Has to be done lazily as we use the DebugContext also during creation of elements...\n            return asElementData(this.elView, this.elDef.nodeIndex).componentView || this.view;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"injector\", {\n        get: function () { return createInjector$1(this.elView, this.elDef); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"component\", {\n        get: function () { return this.elOrCompView.component; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"context\", {\n        get: function () { return this.elOrCompView.context; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"providerTokens\", {\n        get: function () {\n            var tokens = [];\n            if (this.elDef) {\n                for (var i = this.elDef.nodeIndex + 1; i <= this.elDef.nodeIndex + this.elDef.childCount; i++) {\n                    var childDef = this.elView.def.nodes[i];\n                    if (childDef.flags & 20224 /* CatProvider */) {\n                        tokens.push(childDef.provider.token);\n                    }\n                    i += childDef.childCount;\n                }\n            }\n            return tokens;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"references\", {\n        get: function () {\n            var references = {};\n            if (this.elDef) {\n                collectReferences(this.elView, this.elDef, references);\n                for (var i = this.elDef.nodeIndex + 1; i <= this.elDef.nodeIndex + this.elDef.childCount; i++) {\n                    var childDef = this.elView.def.nodes[i];\n                    if (childDef.flags & 20224 /* CatProvider */) {\n                        collectReferences(this.elView, childDef, references);\n                    }\n                    i += childDef.childCount;\n                }\n            }\n            return references;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"componentRenderElement\", {\n        get: function () {\n            var elData = findHostElement(this.elOrCompView);\n            return elData ? elData.renderElement : undefined;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DebugContext_.prototype, \"renderNode\", {\n        get: function () {\n            return this.nodeDef.flags & 2 /* TypeText */ ? renderNode(this.view, this.nodeDef) :\n                renderNode(this.elView, this.elDef);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DebugContext_.prototype.logError = function (console) {\n        var values = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            values[_i - 1] = arguments[_i];\n        }\n        var logViewDef;\n        var logNodeIndex;\n        if (this.nodeDef.flags & 2 /* TypeText */) {\n            logViewDef = this.view.def;\n            logNodeIndex = this.nodeDef.nodeIndex;\n        }\n        else {\n            logViewDef = this.elView.def;\n            logNodeIndex = this.elDef.nodeIndex;\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        var renderNodeIndex = getRenderNodeIndex(logViewDef, logNodeIndex);\n        var currRenderNodeIndex = -1;\n        var nodeLogger = function () {\n            currRenderNodeIndex++;\n            if (currRenderNodeIndex === renderNodeIndex) {\n                return (_a = console.error).bind.apply(_a, __spread([console], values));\n            }\n            else {\n                return NOOP;\n            }\n            var _a;\n        };\n        logViewDef.factory(nodeLogger);\n        if (currRenderNodeIndex < renderNodeIndex) {\n            console.error('Illegal state: the ViewDefinitionFactory did not call the logger!');\n            console.error.apply(console, __spread(values));\n        }\n    };\n    return DebugContext_;\n}());\nfunction getRenderNodeIndex(viewDef$$1, nodeIndex) {\n    var renderNodeIndex = -1;\n    for (var i = 0; i <= nodeIndex; i++) {\n        var nodeDef = viewDef$$1.nodes[i];\n        if (nodeDef.flags & 3 /* CatRenderNode */) {\n            renderNodeIndex++;\n        }\n    }\n    return renderNodeIndex;\n}\nfunction findHostElement(view) {\n    while (view && !isComponentView(view)) {\n        view = view.parent;\n    }\n    if (view.parent) {\n        return asElementData(view.parent, viewParentEl(view).nodeIndex);\n    }\n    return null;\n}\nfunction collectReferences(view, nodeDef, references) {\n    for (var refName in nodeDef.references) {\n        references[refName] = getQueryValue(view, nodeDef, nodeDef.references[refName]);\n    }\n}\nfunction callWithDebugContext(action, fn, self, args) {\n    var oldAction = _currentAction;\n    var oldView = _currentView;\n    var oldNodeIndex = _currentNodeIndex;\n    try {\n        _currentAction = action;\n        var result = fn.apply(self, args);\n        _currentView = oldView;\n        _currentNodeIndex = oldNodeIndex;\n        _currentAction = oldAction;\n        return result;\n    }\n    catch (e) {\n        if (isViewDebugError(e) || !_currentView) {\n            throw e;\n        }\n        throw viewWrappedDebugError(e, getCurrentDebugContext());\n    }\n}\nfunction getCurrentDebugContext() {\n    return _currentView ? new DebugContext_(_currentView, _currentNodeIndex) : null;\n}\nvar DebugRendererFactory2 = /** @class */ (function () {\n    function DebugRendererFactory2(delegate) {\n        this.delegate = delegate;\n    }\n    DebugRendererFactory2.prototype.createRenderer = function (element, renderData) {\n        return new DebugRenderer2(this.delegate.createRenderer(element, renderData));\n    };\n    DebugRendererFactory2.prototype.begin = function () {\n        if (this.delegate.begin) {\n            this.delegate.begin();\n        }\n    };\n    DebugRendererFactory2.prototype.end = function () {\n        if (this.delegate.end) {\n            this.delegate.end();\n        }\n    };\n    DebugRendererFactory2.prototype.whenRenderingDone = function () {\n        if (this.delegate.whenRenderingDone) {\n            return this.delegate.whenRenderingDone();\n        }\n        return Promise.resolve(null);\n    };\n    return DebugRendererFactory2;\n}());\nvar DebugRenderer2 = /** @class */ (function () {\n    function DebugRenderer2(delegate) {\n        this.delegate = delegate;\n        this.data = this.delegate.data;\n    }\n    DebugRenderer2.prototype.destroyNode = function (node) {\n        removeDebugNodeFromIndex(getDebugNode(node));\n        if (this.delegate.destroyNode) {\n            this.delegate.destroyNode(node);\n        }\n    };\n    DebugRenderer2.prototype.destroy = function () { this.delegate.destroy(); };\n    DebugRenderer2.prototype.createElement = function (name, namespace) {\n        var el = this.delegate.createElement(name, namespace);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            var debugEl = new DebugElement(el, null, debugCtx);\n            debugEl.name = name;\n            indexDebugNode(debugEl);\n        }\n        return el;\n    };\n    DebugRenderer2.prototype.createComment = function (value) {\n        var comment = this.delegate.createComment(value);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            indexDebugNode(new DebugNode(comment, null, debugCtx));\n        }\n        return comment;\n    };\n    DebugRenderer2.prototype.createText = function (value) {\n        var text = this.delegate.createText(value);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            indexDebugNode(new DebugNode(text, null, debugCtx));\n        }\n        return text;\n    };\n    DebugRenderer2.prototype.appendChild = function (parent, newChild) {\n        var debugEl = getDebugNode(parent);\n        var debugChildEl = getDebugNode(newChild);\n        if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n            debugEl.addChild(debugChildEl);\n        }\n        this.delegate.appendChild(parent, newChild);\n    };\n    DebugRenderer2.prototype.insertBefore = function (parent, newChild, refChild) {\n        var debugEl = getDebugNode(parent);\n        var debugChildEl = getDebugNode(newChild);\n        var debugRefEl = getDebugNode(refChild);\n        if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n            debugEl.insertBefore(debugRefEl, debugChildEl);\n        }\n        this.delegate.insertBefore(parent, newChild, refChild);\n    };\n    DebugRenderer2.prototype.removeChild = function (parent, oldChild) {\n        var debugEl = getDebugNode(parent);\n        var debugChildEl = getDebugNode(oldChild);\n        if (debugEl && debugChildEl && debugEl instanceof DebugElement) {\n            debugEl.removeChild(debugChildEl);\n        }\n        this.delegate.removeChild(parent, oldChild);\n    };\n    DebugRenderer2.prototype.selectRootElement = function (selectorOrNode) {\n        var el = this.delegate.selectRootElement(selectorOrNode);\n        var debugCtx = getCurrentDebugContext();\n        if (debugCtx) {\n            indexDebugNode(new DebugElement(el, null, debugCtx));\n        }\n        return el;\n    };\n    DebugRenderer2.prototype.setAttribute = function (el, name, value, namespace) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            var fullName = namespace ? namespace + ':' + name : name;\n            debugEl.attributes[fullName] = value;\n        }\n        this.delegate.setAttribute(el, name, value, namespace);\n    };\n    DebugRenderer2.prototype.removeAttribute = function (el, name, namespace) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            var fullName = namespace ? namespace + ':' + name : name;\n            debugEl.attributes[fullName] = null;\n        }\n        this.delegate.removeAttribute(el, name, namespace);\n    };\n    DebugRenderer2.prototype.addClass = function (el, name) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.classes[name] = true;\n        }\n        this.delegate.addClass(el, name);\n    };\n    DebugRenderer2.prototype.removeClass = function (el, name) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.classes[name] = false;\n        }\n        this.delegate.removeClass(el, name);\n    };\n    DebugRenderer2.prototype.setStyle = function (el, style, value, flags) {\n        var 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    DebugRenderer2.prototype.removeStyle = function (el, style, flags) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.styles[style] = null;\n        }\n        this.delegate.removeStyle(el, style, flags);\n    };\n    DebugRenderer2.prototype.setProperty = function (el, name, value) {\n        var debugEl = getDebugNode(el);\n        if (debugEl && debugEl instanceof DebugElement) {\n            debugEl.properties[name] = value;\n        }\n        this.delegate.setProperty(el, name, value);\n    };\n    DebugRenderer2.prototype.listen = function (target, eventName, callback) {\n        if (typeof target !== 'string') {\n            var debugEl = getDebugNode(target);\n            if (debugEl) {\n                debugEl.listeners.push(new EventListener(eventName, callback));\n            }\n        }\n        return this.delegate.listen(target, eventName, callback);\n    };\n    DebugRenderer2.prototype.parentNode = function (node) { return this.delegate.parentNode(node); };\n    DebugRenderer2.prototype.nextSibling = function (node) { return this.delegate.nextSibling(node); };\n    DebugRenderer2.prototype.setValue = function (node, value) { return this.delegate.setValue(node, value); };\n    return DebugRenderer2;\n}());\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction overrideProvider(override) {\n    initServicesIfNeeded();\n    return Services.overrideProvider(override);\n}\nfunction overrideComponentView(comp, componentFactory) {\n    initServicesIfNeeded();\n    return Services.overrideComponentView(comp, componentFactory);\n}\nfunction clearOverrides() {\n    initServicesIfNeeded();\n    return Services.clearOverrides();\n}\n// Attention: this function is called as top level function.\n// Putting any logic in here will destroy closure tree shaking!\nfunction createNgModuleFactory(ngModuleType, bootstrapComponents, defFactory) {\n    return new NgModuleFactory_(ngModuleType, bootstrapComponents, defFactory);\n}\nvar NgModuleFactory_ = /** @class */ (function (_super) {\n    __extends(NgModuleFactory_, _super);\n    function NgModuleFactory_(moduleType, _bootstrapComponents, _ngModuleDefFactory) {\n        var _this = \n        // Attention: this ctor is called as top level function.\n        // Putting any logic in here will destroy closure tree shaking!\n        _super.call(this) || this;\n        _this.moduleType = moduleType;\n        _this._bootstrapComponents = _bootstrapComponents;\n        _this._ngModuleDefFactory = _ngModuleDefFactory;\n        return _this;\n    }\n    NgModuleFactory_.prototype.create = function (parentInjector) {\n        initServicesIfNeeded();\n        var def = resolveDefinition(this._ngModuleDefFactory);\n        return Services.createNgModuleRef(this.moduleType, parentInjector || Injector.NULL, this._bootstrapComponents, def);\n    };\n    return NgModuleFactory_;\n}(NgModuleFactory));\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// The functions in this file verify that the assumptions we are making\n// about state in an instruction are correct before implementing any logic.\n// They are meant only to be called in dev mode as sanity checks.\n\nfunction assertEqual(actual, expected, msg) {\n    if (actual != expected) {\n        throwError(msg);\n    }\n}\nfunction assertNotEqual(actual, expected, msg) {\n    if (actual == expected) {\n        throwError(msg);\n    }\n}\nfunction assertSame(actual, expected, msg) {\n    if (actual !== expected) {\n        throwError(msg);\n    }\n}\nfunction assertLessThan(actual, expected, msg) {\n    if (actual >= expected) {\n        throwError(msg);\n    }\n}\nfunction assertGreaterThan(actual, expected, msg) {\n    if (actual <= expected) {\n        throwError(msg);\n    }\n}\nfunction assertNull(actual, msg) {\n    if (actual != null) {\n        throwError(msg);\n    }\n}\nfunction assertNotNull(actual, msg) {\n    if (actual == null) {\n        throwError(msg);\n    }\n}\nfunction assertComponentType(actual, msg) {\n    if (msg === void 0) { msg = 'Type passed in is not ComponentType, it does not have \\'ngComponentDef\\' property.'; }\n    if (!actual.ngComponentDef) {\n        throwError(msg);\n    }\n}\nfunction throwError(msg) {\n    debugger; // Left intentionally for better debugger experience.\n    throw new Error(\"ASSERTION ERROR: \" + msg);\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 * If this is the first template pass, any ngOnInit or ngDoCheck hooks will be queued into\n * TView.initHooks during directiveCreate.\n *\n * The directive index and hook type are encoded into one number (1st bit: type, remaining bits:\n * directive index), then saved in the even indices of the initHooks array. The odd indices\n * hold the hook functions themselves.\n *\n * @param index The index of the directive in LView.data\n * @param hooks The static hooks map on the directive def\n * @param tView The current TView\n */\nfunction queueInitHooks(index, onInit, doCheck, tView) {\n    ngDevMode &&\n        assertEqual(tView.firstTemplatePass, true, 'Should only be called on first template pass');\n    if (onInit) {\n        (tView.initHooks || (tView.initHooks = [])).push(index, onInit);\n    }\n    if (doCheck) {\n        (tView.initHooks || (tView.initHooks = [])).push(index, doCheck);\n        (tView.checkHooks || (tView.checkHooks = [])).push(index, doCheck);\n    }\n}\n/**\n * Loops through the directives on a node and queues all their hooks except ngOnInit\n * and ngDoCheck, which are queued separately in directiveCreate.\n */\nfunction queueLifecycleHooks(flags, currentView) {\n    var tView = currentView.tView;\n    if (tView.firstTemplatePass === true) {\n        var start = flags >> 13;\n        var count = flags & 4095;\n        var end = start + count;\n        // It's necessary to loop through the directives at elementEnd() (rather than processing in\n        // directiveCreate) so we can preserve the current hook order. Content, view, and destroy\n        // hooks for projected components and directives must be called *before* their hosts.\n        for (var i = start; i < end; i++) {\n            var def = tView.directives[i];\n            queueContentHooks(def, tView, i);\n            queueViewHooks(def, tView, i);\n            queueDestroyHooks(def, tView, i);\n        }\n    }\n}\n/** Queues afterContentInit and afterContentChecked hooks on TView */\nfunction queueContentHooks(def, tView, i) {\n    if (def.afterContentInit) {\n        (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentInit);\n    }\n    if (def.afterContentChecked) {\n        (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentChecked);\n        (tView.contentCheckHooks || (tView.contentCheckHooks = [])).push(i, def.afterContentChecked);\n    }\n}\n/** Queues afterViewInit and afterViewChecked hooks on TView */\nfunction queueViewHooks(def, tView, i) {\n    if (def.afterViewInit) {\n        (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewInit);\n    }\n    if (def.afterViewChecked) {\n        (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewChecked);\n        (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, def.afterViewChecked);\n    }\n}\n/** Queues onDestroy hooks on TView */\nfunction queueDestroyHooks(def, tView, i) {\n    if (def.onDestroy != null) {\n        (tView.destroyHooks || (tView.destroyHooks = [])).push(i, def.onDestroy);\n    }\n}\n/**\n * Calls onInit and doCheck calls if they haven't already been called.\n *\n * @param currentView The current view\n */\nfunction executeInitHooks(currentView, tView, creationMode) {\n    if (currentView.lifecycleStage === 1 /* Init */) {\n        executeHooks(currentView.directives, tView.initHooks, tView.checkHooks, creationMode);\n        currentView.lifecycleStage = 2 /* AfterInit */;\n    }\n}\n/**\n * Iterates over afterViewInit and afterViewChecked functions and calls them.\n *\n * @param currentView The current view\n */\nfunction executeHooks(data, allHooks, checkHooks, creationMode) {\n    var hooksToCall = creationMode ? allHooks : checkHooks;\n    if (hooksToCall) {\n        callHooks(data, hooksToCall);\n    }\n}\n/**\n * Calls lifecycle hooks with their contexts, skipping init hooks if it's not\n * creation mode.\n *\n * @param currentView The current view\n * @param arr The array in which the hooks are found\n */\nfunction callHooks(data, arr) {\n    for (var i = 0; i < arr.length; i += 2) {\n        arr[i + 1].call(data[arr[i]]);\n    }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nif (typeof ngDevMode == 'undefined') {\n    if (typeof window != 'undefined')\n        window.ngDevMode = true;\n    if (typeof self != 'undefined')\n        self.ngDevMode = true;\n    if (typeof global != 'undefined')\n        global.ngDevMode = true;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NG_PROJECT_AS_ATTR_NAME = 'ngProjectAs';\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction assertNodeType(node, type) {\n    assertNotNull(node, 'should be called with a node');\n    assertEqual(node.type, type, \"should be a \" + typeName(type));\n}\nfunction assertNodeOfPossibleTypes(node) {\n    var types = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        types[_i - 1] = arguments[_i];\n    }\n    assertNotNull(node, 'should be called with a node');\n    var found = types.some(function (type) { return node.type === type; });\n    assertEqual(found, true, \"Should be one of \" + types.map(typeName).join(', '));\n}\nfunction typeName(type) {\n    if (type == 1 /* Projection */)\n        return 'Projection';\n    if (type == 0 /* Container */)\n        return 'Container';\n    if (type == 2 /* View */)\n        return 'View';\n    if (type == 3 /* Element */)\n        return 'Element';\n    return '<unknown>';\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// TODO: cleanup once the code is merged in angular/angular\nvar RendererStyleFlags3;\n(function (RendererStyleFlags3) {\n    RendererStyleFlags3[RendererStyleFlags3[\"Important\"] = 1] = \"Important\";\n    RendererStyleFlags3[RendererStyleFlags3[\"DashCase\"] = 2] = \"DashCase\";\n})(RendererStyleFlags3 || (RendererStyleFlags3 = {}));\n/** Returns whether the `renderer` is a `ProceduralRenderer3` */\nfunction isProceduralRenderer(renderer) {\n    return !!(renderer.listen);\n}\nvar domRendererFactory3 = {\n    createRenderer: function (hostElement, rendererType) { return document; }\n};\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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* Must use this method for CD (instead of === ) since NaN !== NaN\n*/\nfunction isDifferent(a, b) {\n    // NaN is the only value that is not equal to itself so the first\n    // test checks if both a and b are not NaN\n    return !(a !== a && b !== b) && a !== b;\n}\nfunction stringify$1(value) {\n    if (typeof value == 'function')\n        return value.name || value;\n    if (typeof value == 'string')\n        return value;\n    if (value == null)\n        return '';\n    return '' + value;\n}\n/**\n *  Function that throws a \"not implemented\" error so it's clear certain\n *  behaviors/methods aren't yet ready.\n *\n * @returns Not implemented error\n */\nfunction notImplemented() {\n    return new Error('NotImplemented');\n}\n/**\n * Flattens an array in non-recursive way. Input arrays are not modified.\n */\nfunction flatten$1(list) {\n    var result = [];\n    var i = 0;\n    while (i < list.length) {\n        var item = list[i];\n        if (Array.isArray(item)) {\n            if (item.length > 0) {\n                list = item.concat(list.slice(i + 1));\n                i = 0;\n            }\n            else {\n                i++;\n            }\n        }\n        else {\n            result.push(item);\n            i++;\n        }\n    }\n    return result;\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 * Returns the first RNode following the given LNode in the same parent DOM element.\n *\n * This is needed in order to insert the given node with insertBefore.\n *\n * @param node The node whose following DOM node must be found.\n * @param stopNode A parent node at which the lookup in the tree should be stopped, or null if the\n * lookup should not be stopped until the result is found.\n * @returns RNode before which the provided node should be inserted or null if the lookup was\n * stopped\n * or if there is no native node after the given logical node in the same native parent.\n */\nfunction findNextRNodeSibling(node, stopNode) {\n    var currentNode = node;\n    while (currentNode && currentNode !== stopNode) {\n        var pNextOrParent = currentNode.pNextOrParent;\n        if (pNextOrParent) {\n            while (pNextOrParent.type !== 1 /* Projection */) {\n                var nativeNode = findFirstRNode(pNextOrParent);\n                if (nativeNode) {\n                    return nativeNode;\n                }\n                pNextOrParent = pNextOrParent.pNextOrParent;\n            }\n            currentNode = pNextOrParent;\n        }\n        else {\n            var currentSibling = currentNode.next;\n            while (currentSibling) {\n                var nativeNode = findFirstRNode(currentSibling);\n                if (nativeNode) {\n                    return nativeNode;\n                }\n                currentSibling = currentSibling.next;\n            }\n            var parentNode = currentNode.parent;\n            currentNode = null;\n            if (parentNode) {\n                var parentType = parentNode.type;\n                if (parentType === 0 /* Container */ || parentType === 2 /* View */) {\n                    currentNode = parentNode;\n                }\n            }\n        }\n    }\n    return null;\n}\n/**\n * Get the next node in the LNode tree, taking into account the place where a node is\n * projected (in the shadow DOM) rather than where it comes from (in the light DOM).\n *\n * @param node The node whose next node in the LNode tree must be found.\n * @return LNode|null The next sibling in the LNode tree.\n */\nfunction getNextLNodeWithProjection(node) {\n    var pNextOrParent = node.pNextOrParent;\n    if (pNextOrParent) {\n        // The node is projected\n        var isLastProjectedNode = pNextOrParent.type === 1;\n        // returns pNextOrParent if we are not at the end of the list, null otherwise\n        return isLastProjectedNode ? null : pNextOrParent;\n    }\n    // returns node.next because the the node is not projected\n    return node.next;\n}\n/**\n * Find the next node in the LNode tree, taking into account the place where a node is\n * projected (in the shadow DOM) rather than where it comes from (in the light DOM).\n *\n * If there is no sibling node, this function goes to the next sibling of the parent node...\n * until it reaches rootNode (at which point null is returned).\n *\n * @param initialNode The node whose following node in the LNode tree must be found.\n * @param rootNode The root node at which the lookup should stop.\n * @return LNode|null The following node in the LNode tree.\n */\nfunction getNextOrParentSiblingNode(initialNode, rootNode) {\n    var node = initialNode;\n    var nextNode = getNextLNodeWithProjection(node);\n    while (node && !nextNode) {\n        // if node.pNextOrParent is not null here, it is not the next node\n        // (because, at this point, nextNode is null, so it is the parent)\n        node = node.pNextOrParent || node.parent;\n        if (node === rootNode) {\n            return null;\n        }\n        nextNode = node && getNextLNodeWithProjection(node);\n    }\n    return nextNode;\n}\n/**\n * Returns the first RNode inside the given LNode.\n *\n * @param node The node whose first DOM node must be found\n * @returns RNode The first RNode of the given LNode or null if there is none.\n */\nfunction findFirstRNode(rootNode) {\n    var node = rootNode;\n    while (node) {\n        var nextNode = null;\n        if (node.type === 3 /* Element */) {\n            // A LElementNode has a matching RNode in LElementNode.native\n            return node.native;\n        }\n        else if (node.type === 0 /* Container */) {\n            var lContainerNode = node;\n            var childContainerData = lContainerNode.dynamicLContainerNode ?\n                lContainerNode.dynamicLContainerNode.data :\n                lContainerNode.data;\n            nextNode = childContainerData.views.length ? childContainerData.views[0].child : null;\n        }\n        else if (node.type === 1 /* Projection */) {\n            // For Projection look at the first projected node\n            nextNode = node.data.head;\n        }\n        else {\n            // Otherwise look at the first child\n            nextNode = node.child;\n        }\n        node = nextNode === null ? getNextOrParentSiblingNode(node, rootNode) : nextNode;\n    }\n    return null;\n}\nfunction createTextNode(value, renderer) {\n    return isProceduralRenderer(renderer) ? renderer.createText(stringify$1(value)) :\n        renderer.createTextNode(stringify$1(value));\n}\nfunction addRemoveViewFromContainer(container, rootNode, insertMode, beforeNode) {\n    ngDevMode && assertNodeType(container, 0 /* Container */);\n    ngDevMode && assertNodeType(rootNode, 2 /* View */);\n    var parentNode = container.data.renderParent;\n    var parent = parentNode ? parentNode.native : null;\n    var node = rootNode.child;\n    if (parent) {\n        while (node) {\n            var nextNode = null;\n            var renderer = container.view.renderer;\n            if (node.type === 3 /* Element */) {\n                if (insertMode) {\n                    if (!node.native) {\n                        // If the native element doesn't exist, this is a bound text node that hasn't yet been\n                        // created because update mode has not run (occurs when a bound text node is a root\n                        // node of a dynamically created view). See textBinding() in instructions for ctx.\n                        node.native = createTextNode('', renderer);\n                    }\n                    isProceduralRenderer(renderer) ?\n                        renderer.insertBefore(parent, node.native, beforeNode) :\n                        parent.insertBefore(node.native, beforeNode, true);\n                }\n                else {\n                    isProceduralRenderer(renderer) ? renderer.removeChild(parent, node.native) :\n                        parent.removeChild(node.native);\n                }\n                nextNode = node.next;\n            }\n            else if (node.type === 0 /* Container */) {\n                // if we get to a container, it must be a root node of a view because we are only\n                // propagating down into child views / containers and not child elements\n                var childContainerData = node.data;\n                childContainerData.renderParent = parentNode;\n                nextNode = childContainerData.views.length ? childContainerData.views[0].child : null;\n            }\n            else if (node.type === 1 /* Projection */) {\n                nextNode = node.data.head;\n            }\n            else {\n                nextNode = node.child;\n            }\n            if (nextNode === null) {\n                node = getNextOrParentSiblingNode(node, rootNode);\n            }\n            else {\n                node = nextNode;\n            }\n        }\n    }\n}\n/**\n * Traverses the tree of component views and containers to remove listeners and\n * call onDestroy callbacks.\n *\n * Notes:\n *  - Because it's used for onDestroy calls, it needs to be bottom-up.\n *  - Must process containers instead of their views to avoid splicing\n *  when views are destroyed and re-added.\n *  - Using a while loop because it's faster than recursion\n *  - Destroy only called on movement to sibling or movement to parent (laterally or up)\n *\n *  @param rootView The view to destroy\n */\nfunction destroyViewTree(rootView) {\n    var viewOrContainer = rootView;\n    while (viewOrContainer) {\n        var next = null;\n        if (viewOrContainer.views && viewOrContainer.views.length) {\n            next = viewOrContainer.views[0].data;\n        }\n        else if (viewOrContainer.child) {\n            next = viewOrContainer.child;\n        }\n        else if (viewOrContainer.next) {\n            cleanUpView(viewOrContainer);\n            next = viewOrContainer.next;\n        }\n        if (next == null) {\n            // If the viewOrContainer is the rootView, then the cleanup is done twice.\n            // Without this check, ngOnDestroy would be called twice for a directive on an element.\n            while (viewOrContainer && !viewOrContainer.next && viewOrContainer !== rootView) {\n                cleanUpView(viewOrContainer);\n                viewOrContainer = getParentState(viewOrContainer, rootView);\n            }\n            cleanUpView(viewOrContainer || rootView);\n            next = viewOrContainer && viewOrContainer.next;\n        }\n        viewOrContainer = next;\n    }\n}\n/**\n * Inserts a view into a container.\n *\n * This adds the view to the container's array of active views in the correct\n * position. It also adds the view's elements to the DOM if the container isn't a\n * root node of another view (in that case, the view's elements will be added when\n * the container's parent view is added later).\n *\n * @param container The container into which the view should be inserted\n * @param newView The view to insert\n * @param index The index at which to insert the view\n * @returns The inserted view\n */\nfunction insertView(container, newView, index) {\n    var state = container.data;\n    var views = state.views;\n    if (index > 0) {\n        // This is a new view, we need to add it to the children.\n        setViewNext(views[index - 1], newView);\n    }\n    if (index < views.length) {\n        setViewNext(newView, views[index]);\n        views.splice(index, 0, newView);\n    }\n    else {\n        views.push(newView);\n    }\n    // If the container's renderParent is null, we know that it is a root node of its own parent view\n    // and we should wait until that parent processes its nodes (otherwise, we will insert this view's\n    // nodes twice - once now and once when its parent inserts its views).\n    if (container.data.renderParent !== null) {\n        var beforeNode = findNextRNodeSibling(newView, container);\n        if (!beforeNode) {\n            var containerNextNativeNode = container.native;\n            if (containerNextNativeNode === undefined) {\n                containerNextNativeNode = container.native = findNextRNodeSibling(container, null);\n            }\n            beforeNode = containerNextNativeNode;\n        }\n        addRemoveViewFromContainer(container, newView, true, beforeNode);\n    }\n    return newView;\n}\n/**\n * Removes a view from a container.\n *\n * This method splices the view from the container's array of active views. It also\n * removes the view's elements from the DOM and conducts cleanup (e.g. removing\n * listeners, calling onDestroys).\n *\n * @param container The container from which to remove a view\n * @param removeIndex The index of the view to remove\n * @returns The removed view\n */\nfunction removeView(container, removeIndex) {\n    var views = container.data.views;\n    var viewNode = views[removeIndex];\n    if (removeIndex > 0) {\n        setViewNext(views[removeIndex - 1], viewNode.next);\n    }\n    views.splice(removeIndex, 1);\n    viewNode.next = null;\n    destroyViewTree(viewNode.data);\n    addRemoveViewFromContainer(container, viewNode, false);\n    // Notify query that view has been removed\n    container.data.queries && container.data.queries.removeView(removeIndex);\n    return viewNode;\n}\n/**\n * Sets a next on the view node, so views in for loops can easily jump from\n * one view to the next to add/remove elements. Also adds the LView (view.data)\n * to the view tree for easy traversal when cleaning up the view.\n *\n * @param view The view to set up\n * @param next The view's new next\n */\nfunction setViewNext(view, next) {\n    view.next = next;\n    view.data.next = next ? next.data : null;\n}\n/**\n * Determines which LViewOrLContainer to jump to when traversing back up the\n * tree in destroyViewTree.\n *\n * Normally, the view's parent LView should be checked, but in the case of\n * embedded views, the container (which is the view node's parent, but not the\n * LView's parent) needs to be checked for a possible next property.\n *\n * @param state The LViewOrLContainer for which we need a parent state\n * @param rootView The rootView, so we don't propagate too far up the view tree\n * @returns The correct parent LViewOrLContainer\n */\nfunction getParentState(state, rootView) {\n    var node;\n    if ((node = state.node) && node.type === 2 /* View */) {\n        // if it's an embedded view, the state needs to go up to the container, in case the\n        // container has a next\n        return node.parent.data;\n    }\n    else {\n        // otherwise, use parent view for containers or component views\n        return state.parent === rootView ? null : state.parent;\n    }\n}\n/**\n * Removes all listeners and call all onDestroys in a given view.\n *\n * @param view The LView to clean up\n */\nfunction cleanUpView(view) {\n    removeListeners(view);\n    executeOnDestroys(view);\n    executePipeOnDestroys(view);\n}\n/** Removes listeners and unsubscribes from output subscriptions */\nfunction removeListeners(view) {\n    var cleanup = view.cleanup;\n    if (cleanup != null) {\n        for (var i = 0; i < cleanup.length - 1; i += 2) {\n            if (typeof cleanup[i] === 'string') {\n                cleanup[i + 1].removeEventListener(cleanup[i], cleanup[i + 2], cleanup[i + 3]);\n                i += 2;\n            }\n            else {\n                cleanup[i].call(cleanup[i + 1]);\n            }\n        }\n        view.cleanup = null;\n    }\n}\n/** Calls onDestroy hooks for this view */\nfunction executeOnDestroys(view) {\n    var tView = view.tView;\n    var destroyHooks;\n    if (tView != null && (destroyHooks = tView.destroyHooks) != null) {\n        callHooks(view.directives, destroyHooks);\n    }\n}\n/** Calls pipe destroy hooks for this view */\nfunction executePipeOnDestroys(view) {\n    var pipeDestroyHooks = view.tView && view.tView.pipeDestroyHooks;\n    if (pipeDestroyHooks) {\n        callHooks(view.data, pipeDestroyHooks);\n    }\n}\n/**\n * Returns whether a native element should be inserted in the given parent.\n *\n * The native node can be inserted when its parent is:\n * - A regular element => Yes\n * - A component host element =>\n *    - if the `currentView` === the parent `view`: The element is in the content (vs the\n *      template)\n *      => don't add as the parent component will project if needed.\n *    - `currentView` !== the parent `view` => The element is in the template (vs the content),\n *      add it\n * - View element => delay insertion, will be done on `viewEnd()`\n *\n * @param parent The parent in which to insert the child\n * @param currentView The LView being processed\n * @return boolean Whether the child element should be inserted.\n */\nfunction canInsertNativeNode(parent, currentView) {\n    var parentIsElement = parent.type === 3;\n    return parentIsElement &&\n        (parent.view !== currentView || parent.data === null /* Regular Element. */);\n}\n/**\n * Appends the `child` element to the `parent`.\n *\n * The element insertion might be delayed {@link canInsertNativeNode}\n *\n * @param parent The parent to which to append the child\n * @param child The child that should be appended\n * @param currentView The current LView\n * @returns Whether or not the child was appended\n */\nfunction appendChild(parent, child, currentView) {\n    if (child !== null && canInsertNativeNode(parent, currentView)) {\n        // We only add element if not in View or not projected.\n        var renderer = currentView.renderer;\n        isProceduralRenderer(renderer) ? renderer.appendChild(parent.native, child) :\n            parent.native.appendChild(child);\n        return true;\n    }\n    return false;\n}\n/**\n * Inserts the provided node before the correct element in the DOM.\n *\n * The element insertion might be delayed {@link canInsertNativeNode}\n *\n * @param node Node to insert\n * @param currentView Current LView\n */\nfunction insertChild(node, currentView) {\n    var parent = node.parent;\n    if (canInsertNativeNode(parent, currentView)) {\n        var nativeSibling = findNextRNodeSibling(node, null);\n        var renderer = currentView.renderer;\n        isProceduralRenderer(renderer) ?\n            renderer.insertBefore(parent.native, node.native, nativeSibling) :\n            parent.native.insertBefore(node.native, nativeSibling, false);\n    }\n}\n/**\n * Appends a projected node to the DOM, or in the case of a projected container,\n * appends the nodes from all of the container's active views to the DOM.\n *\n * @param node The node to process\n * @param currentParent The last parent element to be processed\n * @param currentView Current LView\n */\nfunction appendProjectedNode(node, currentParent, currentView) {\n    if (node.type !== 0 /* Container */) {\n        appendChild(currentParent, node.native, currentView);\n    }\n    else {\n        // The node we are adding is a Container and we are adding it to Element which\n        // is not a component (no more re-projection).\n        // Alternatively a container is projected at the root of a component's template\n        // and can't be re-projected (as not content of any component).\n        // Assignee the final projection location in those cases.\n        var lContainer = node.data;\n        lContainer.renderParent = currentParent;\n        var views = lContainer.views;\n        for (var i = 0; i < views.length; i++) {\n            addRemoveViewFromContainer(node, views[i], true, null);\n        }\n    }\n    if (node.dynamicLContainerNode) {\n        node.dynamicLContainerNode.data.renderParent = currentParent;\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 */\nfunction isCssClassMatching(nodeClassAttrVal, cssClassToMatch) {\n    var nodeClassesLen = nodeClassAttrVal.length;\n    var matchIndex = nodeClassAttrVal.indexOf(cssClassToMatch);\n    var matchEndIdx = matchIndex + cssClassToMatch.length;\n    if (matchIndex === -1 // no match\n        || (matchIndex > 0 && nodeClassAttrVal[matchIndex - 1] !== ' ') // no space before\n        ||\n            (matchEndIdx < nodeClassesLen && nodeClassAttrVal[matchEndIdx] !== ' ')) {\n        return false;\n    }\n    return true;\n}\n/**\n * A utility function to match an Ivy node static data against a simple CSS selector\n *\n * @param node static data to match\n * @param selector\n * @returns true if node matches the selector.\n */\nfunction isNodeMatchingSelector(tNode, selector) {\n    ngDevMode && assertNotNull(selector[0], 'Selector should have a tag name');\n    var mode = 4;\n    var nodeAttrs = tNode.attrs;\n    // When processing \":not\" selectors, we skip to the next \":not\" if the\n    // current one doesn't match\n    var skipToNextSelector = false;\n    for (var i = 0; i < selector.length; i++) {\n        var current = selector[i];\n        if (typeof current === 'number') {\n            // If we finish processing a :not selector and it hasn't failed, return false\n            if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {\n                return false;\n            }\n            // If we are skipping to the next :not() and this mode flag is positive,\n            // it's a part of the current :not() selector, and we should keep skipping\n            if (skipToNextSelector && isPositive(current))\n                continue;\n            skipToNextSelector = false;\n            mode = current | (mode & 1 /* NOT */);\n            continue;\n        }\n        if (skipToNextSelector)\n            continue;\n        if (mode & 4 /* ELEMENT */) {\n            mode = 2 /* ATTRIBUTE */ | mode & 1 /* NOT */;\n            if (current !== '' && current !== tNode.tagName) {\n                if (isPositive(mode))\n                    return false;\n                skipToNextSelector = true;\n            }\n        }\n        else {\n            var attrName = mode & 8 /* CLASS */ ? 'class' : current;\n            var attrIndexInNode = findAttrIndexInNode(attrName, nodeAttrs);\n            if (attrIndexInNode === -1) {\n                if (isPositive(mode))\n                    return false;\n                skipToNextSelector = true;\n                continue;\n            }\n            var selectorAttrValue = mode & 8 /* CLASS */ ? current : selector[++i];\n            if (selectorAttrValue !== '') {\n                var nodeAttrValue = nodeAttrs[attrIndexInNode + 1];\n                if (mode & 8 /* CLASS */ &&\n                    !isCssClassMatching(nodeAttrValue, selectorAttrValue) ||\n                    mode & 2 /* ATTRIBUTE */ && selectorAttrValue !== nodeAttrValue) {\n                    if (isPositive(mode))\n                        return false;\n                    skipToNextSelector = true;\n                }\n            }\n        }\n    }\n    return isPositive(mode) || skipToNextSelector;\n}\nfunction isPositive(mode) {\n    return (mode & 1 /* NOT */) === 0;\n}\nfunction findAttrIndexInNode(name, attrs) {\n    if (attrs === null)\n        return -1;\n    for (var i = 0; i < attrs.length; i += 2) {\n        if (attrs[i] === name)\n            return i;\n    }\n    return -1;\n}\nfunction isNodeMatchingSelectorList(tNode, selector) {\n    for (var i = 0; i < selector.length; i++) {\n        if (isNodeMatchingSelector(tNode, selector[i])) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction getProjectAsAttrValue(tNode) {\n    var nodeAttrs = tNode.attrs;\n    if (nodeAttrs != null) {\n        var ngProjectAsAttrIdx = nodeAttrs.indexOf(NG_PROJECT_AS_ATTR_NAME);\n        // only check for ngProjectAs in attribute names, don't accidentally match attribute's value\n        // (attribute names are stored at even indexes)\n        if ((ngProjectAsAttrIdx & 1) === 0) {\n            return nodeAttrs[ngProjectAsAttrIdx + 1];\n        }\n    }\n    return null;\n}\n/**\n * Checks a given node against matching selectors and returns\n * selector index (or 0 if none matched).\n *\n * This function takes into account the ngProjectAs attribute: if present its value will be compared\n * to the raw (un-parsed) CSS selector instead of using standard selector matching logic.\n */\nfunction matchingSelectorIndex(tNode, selectors, textSelectors) {\n    var ngProjectAsAttrVal = getProjectAsAttrValue(tNode);\n    for (var i = 0; i < selectors.length; i++) {\n        // if a node has the ngProjectAs attribute match it against unparsed selector\n        // match a node against a parsed selector only if ngProjectAs attribute is not present\n        if (ngProjectAsAttrVal === textSelectors[i] ||\n            ngProjectAsAttrVal === null && isNodeMatchingSelectorList(tNode, selectors[i])) {\n            return i + 1; // first matching selector \"captures\" a given node\n        }\n    }\n    return 0;\n}\n\n/** Called when directives inject each other (creating a circular dependency) */\nfunction throwCyclicDependencyError(token) {\n    throw new Error(\"Cannot instantiate cyclic dependency! \" + token);\n}\n/** Called when there are multiple component selectors that match a given node */\nfunction throwMultipleComponentError(tNode) {\n    throw new Error(\"Multiple components match node with tagname \" + tNode.tagName);\n}\n/** Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on. */\nfunction throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, oldValue, currValue) {\n    if (checkNoChangesMode) {\n        var msg = \"ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: '\" + oldValue + \"'. Current value: '\" + currValue + \"'.\";\n        if (creationMode) {\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        // TODO: include debug context\n        throw new Error(msg);\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 * Directive (D) sets a property on all component instances using this constant as a key and the\n * component's host node (LElement) as the value. This is used in methods like detectChanges to\n * facilitate jumping from an instance to the host node.\n */\nvar NG_HOST_SYMBOL = '__ngHostLNode__';\n/**\n * A permanent marker promise which signifies that the current CD tree is\n * clean.\n */\nvar _CLEAN_PROMISE = Promise.resolve(null);\n/**\n * Directive and element indices for top-level directive.\n *\n * Saved here to avoid re-instantiating an array on every change detection run.\n */\nvar _ROOT_DIRECTIVE_INDICES = [0, 0];\n/**\n * Token set in currentMatches while dependencies are being resolved.\n *\n * If we visit a directive that has a value set to CIRCULAR, we know we've\n * already seen it, and thus have a circular dependency.\n */\nvar CIRCULAR$2 = '__CIRCULAR__';\n/**\n * This property gets set before entering a template.\n *\n * This renderer can be one of two varieties of Renderer3:\n *\n * - ObjectedOrientedRenderer3\n *\n * This is the native browser API style, e.g. operations are methods on individual objects\n * like HTMLElement. With this style, no additional code is needed as a facade (reducing payload\n * size).\n *\n * - ProceduralRenderer3\n *\n * In non-native browser environments (e.g. platforms such as web-workers), this is the facade\n * that enables element manipulation. This also facilitates backwards compatibility with\n * Renderer2.\n */\nvar renderer;\nvar rendererFactory;\nfunction getRenderer() {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return renderer;\n}\n/** Used to set the parent property when nodes are created. */\nvar previousOrParentNode;\nfunction getPreviousOrParentNode() {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return previousOrParentNode;\n}\n/**\n * If `isParent` is:\n *  - `true`: then `previousOrParentNode` points to a parent node.\n *  - `false`: then `previousOrParentNode` points to previous node (sibling).\n */\nvar isParent;\n/**\n * Static data that corresponds to the instance-specific data array on an LView.\n *\n * Each node's static data is stored in tData at the same index that it's stored\n * in the data array. Any nodes that do not have static data store a null value in\n * tData to avoid a sparse array.\n */\nvar tData;\n/**\n * State of the current view being processed.\n *\n * NOTE: we cheat here and initialize it to `null` even thought the type does not\n * contain `null`. This is because we expect this value to be not `null` as soon\n * as we enter the view. Declaring the type as `null` would require us to place `!`\n * in most instructions since they all assume that `currentView` is defined.\n */\nvar currentView = null;\nvar currentQueries;\nfunction getCurrentQueries(QueryType) {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return currentQueries || (currentQueries = new QueryType());\n}\n/**\n * This property gets set before entering a template.\n */\nvar creationMode;\nfunction getCreationMode() {\n    // top level variables should not be exported for performance reason (PERF_NOTES.md)\n    return creationMode;\n}\n/**\n * An array of nodes (text, element, container, etc), pipes, their bindings, and\n * any local variables that need to be stored between invocations.\n */\nvar data;\n/**\n * An array of directive instances in the current view.\n *\n * These must be stored separately from LNodes because their presence is\n * unknown at compile-time and thus space cannot be reserved in data[].\n */\nvar directives;\n/**\n * When a view is destroyed, listeners need to be released and outputs need to be\n * unsubscribed. This cleanup array stores both listener data (in chunks of 4)\n * and output data (in chunks of 2) for a particular view. Combining the arrays\n * saves on memory (70 bytes per array) and on a few bytes of code size (for two\n * separate for loops).\n *\n * If it's a listener being stored:\n * 1st index is: event name to remove\n * 2nd index is: native element\n * 3rd index is: listener function\n * 4th index is: useCapture boolean\n *\n * If it's an output subscription:\n * 1st index is: unsubscribe function\n * 2nd index is: context for function\n */\nvar cleanup;\n/**\n * In this mode, any changes in bindings will throw an ExpressionChangedAfterChecked error.\n *\n * Necessary to support ChangeDetectorRef.checkNoChanges().\n */\nvar checkNoChangesMode = false;\n/** Whether or not this is the first time the current view has been processed. */\nvar firstTemplatePass = true;\n/**\n * Swap the current state with a new state.\n *\n * For performance reasons we store the state in the top level of the module.\n * This way we minimize the number of properties to read. Whenever a new view\n * is entered we have to store the state for later, and when the view is\n * exited the state has to be restored\n *\n * @param newView New state to become active\n * @param host Element to which the View is a child of\n * @returns the previous state;\n */\nfunction enterView(newView, host) {\n    var oldView = currentView;\n    data = newView && newView.data;\n    directives = newView && newView.directives;\n    tData = newView && newView.tView.data;\n    creationMode = newView && (newView.flags & 1 /* CreationMode */) === 1 /* CreationMode */;\n    firstTemplatePass = newView && newView.tView.firstTemplatePass;\n    cleanup = newView && newView.cleanup;\n    renderer = newView && newView.renderer;\n    if (newView && newView.bindingIndex < 0) {\n        newView.bindingIndex = newView.bindingStartIndex;\n    }\n    if (host != null) {\n        previousOrParentNode = host;\n        isParent = true;\n    }\n    currentView = newView;\n    currentQueries = newView && newView.queries;\n    return oldView;\n}\n/**\n * Used in lieu of enterView to make it clear when we are exiting a child view. This makes\n * the direction of traversal (up or down the view tree) a bit clearer.\n */\nfunction leaveView(newView) {\n    if (!checkNoChangesMode) {\n        executeHooks(directives, currentView.tView.viewHooks, currentView.tView.viewCheckHooks, creationMode);\n    }\n    // Views should be clean and in update mode after being checked, so these bits are cleared\n    currentView.flags &= ~(1 /* CreationMode */ | 4 /* Dirty */);\n    currentView.lifecycleStage = 1 /* Init */;\n    currentView.bindingIndex = -1;\n    enterView(newView, null);\n}\n/**  Refreshes directives in this view and triggers any init/content hooks.  */\nfunction refreshDirectives() {\n    executeInitAndContentHooks();\n    var tView = currentView.tView;\n    // This needs to be set before children are processed to support recursive components\n    tView.firstTemplatePass = firstTemplatePass = false;\n    setHostBindings(tView.hostBindings);\n    refreshChildComponents(tView.components);\n}\n/** Sets the host bindings for the current view. */\nfunction setHostBindings(bindings) {\n    if (bindings != null) {\n        var defs = currentView.tView.directives;\n        for (var i = 0; i < bindings.length; i += 2) {\n            var dirIndex = bindings[i];\n            var def = defs[dirIndex];\n            def.hostBindings && def.hostBindings(dirIndex, bindings[i + 1]);\n        }\n    }\n}\n/** Refreshes child components in the current view. */\nfunction refreshChildComponents(components) {\n    if (components != null) {\n        for (var i = 0; i < components.length; i += 2) {\n            componentRefresh(components[i], components[i + 1]);\n        }\n    }\n}\nfunction executeInitAndContentHooks() {\n    if (!checkNoChangesMode) {\n        var tView = currentView.tView;\n        executeInitHooks(currentView, tView, creationMode);\n        executeHooks(directives, tView.contentHooks, tView.contentCheckHooks, creationMode);\n    }\n}\nfunction createLView(viewId, renderer, tView, template, context, flags) {\n    var newView = {\n        parent: currentView,\n        id: viewId,\n        flags: flags | 1 /* CreationMode */ | 8 /* Attached */,\n        node: null,\n        data: [],\n        directives: null,\n        tView: tView,\n        cleanup: null,\n        renderer: renderer,\n        child: null,\n        tail: null,\n        next: null,\n        bindingStartIndex: -1,\n        bindingIndex: -1,\n        template: template,\n        context: context,\n        dynamicViewCount: 0,\n        lifecycleStage: 1 /* Init */,\n        queries: null,\n        injector: currentView && currentView.injector,\n    };\n    return newView;\n}\n/**\n * Creation of LNode object is extracted to a separate function so we always create LNode object\n * with the same shape\n * (same properties assigned in the same order).\n */\nfunction createLNodeObject(type, currentView, parent, native, state, queries) {\n    return {\n        type: type,\n        native: native,\n        view: currentView,\n        parent: parent,\n        child: null,\n        next: null,\n        nodeInjector: parent ? parent.nodeInjector : null,\n        data: state,\n        queries: queries,\n        tNode: null,\n        pNextOrParent: null,\n        dynamicLContainerNode: null\n    };\n}\nfunction createLNode(index, type, native, state) {\n    var parent = isParent ? previousOrParentNode :\n        previousOrParentNode && previousOrParentNode.parent;\n    var queries = (isParent ? currentQueries : previousOrParentNode && previousOrParentNode.queries) ||\n        parent && parent.queries && parent.queries.child();\n    var isState = state != null;\n    var node = createLNodeObject(type, currentView, parent, native, isState ? state : null, queries);\n    if ((type & 2 /* ViewOrElement */) === 2 /* ViewOrElement */ && isState) {\n        // Bit of a hack to bust through the readonly because there is a circular dep between\n        // LView and LNode.\n        ngDevMode && assertNull(state.node, 'LView.node should not have been initialized');\n        state.node = node;\n    }\n    if (index != null) {\n        // We are Element or Container\n        ngDevMode && assertDataNext(index);\n        data[index] = node;\n        // Every node adds a value to the static data array to avoid a sparse array\n        if (index >= tData.length) {\n            tData[index] = null;\n        }\n        else {\n            node.tNode = tData[index];\n        }\n        // Now link ourselves into the tree.\n        if (isParent) {\n            currentQueries = null;\n            if (previousOrParentNode.view === currentView ||\n                previousOrParentNode.type === 2 /* View */) {\n                // We are in the same view, which means we are adding content node to the parent View.\n                ngDevMode && assertNull(previousOrParentNode.child, \"previousOrParentNode's child should not have been set.\");\n                previousOrParentNode.child = node;\n            }\n            else {\n                // We are adding component view, so we don't link parent node child to this node.\n            }\n        }\n        else if (previousOrParentNode) {\n            ngDevMode && assertNull(previousOrParentNode.next, \"previousOrParentNode's next property should not have been set \" + index + \".\");\n            previousOrParentNode.next = node;\n            if (previousOrParentNode.dynamicLContainerNode) {\n                previousOrParentNode.dynamicLContainerNode.next = node;\n            }\n        }\n    }\n    previousOrParentNode = node;\n    isParent = true;\n    return node;\n}\n//////////////////////////\n//// Render\n//////////////////////////\n/**\n * Resets the application state.\n */\nfunction resetApplicationState() {\n    isParent = false;\n    previousOrParentNode = null;\n}\n/**\n *\n * @param hostNode Existing node to render into.\n * @param template Template function with the instructions.\n * @param context to pass into the template.\n * @param providedRendererFactory renderer factory to use\n * @param host The host element node to use\n * @param directives Directive defs that should be used for matching\n * @param pipes Pipe defs that should be used for matching\n */\n\nfunction renderEmbeddedTemplate(viewNode, template, context, renderer, directives, pipes) {\n    var _isParent = isParent;\n    var _previousOrParentNode = previousOrParentNode;\n    var oldView;\n    try {\n        isParent = true;\n        previousOrParentNode = null;\n        var rf = 2;\n        if (viewNode == null) {\n            var tView = getOrCreateTView(template, directives || null, pipes || null);\n            var lView = createLView(-1, renderer, tView, template, context, 2 /* CheckAlways */);\n            viewNode = createLNode(null, 2 /* View */, null, lView);\n            rf = 1 /* Create */;\n        }\n        oldView = enterView(viewNode.data, viewNode);\n        template(rf, context);\n        refreshDirectives();\n        refreshDynamicChildren();\n    }\n    finally {\n        leaveView(oldView);\n        isParent = _isParent;\n        previousOrParentNode = _previousOrParentNode;\n    }\n    return viewNode;\n}\nfunction renderComponentOrTemplate(node, hostView, componentOrContext, template) {\n    var oldView = enterView(hostView, node);\n    try {\n        if (rendererFactory.begin) {\n            rendererFactory.begin();\n        }\n        if (template) {\n            template(getRenderFlags(hostView), componentOrContext);\n            refreshDynamicChildren();\n            refreshDirectives();\n        }\n        else {\n            executeInitAndContentHooks();\n            // Element was stored at 0 in data and directive was stored at 0 in directives\n            // in renderComponent()\n            setHostBindings(_ROOT_DIRECTIVE_INDICES);\n            componentRefresh(0, 0);\n        }\n    }\n    finally {\n        if (rendererFactory.end) {\n            rendererFactory.end();\n        }\n        leaveView(oldView);\n    }\n}\n/**\n * This function returns the default configuration of rendering flags depending on when the\n * template is in creation mode or update mode. By default, the update block is run with the\n * creation block when the view is in creation mode. Otherwise, the update block is run\n * alone.\n *\n * Dynamically created views do NOT use this configuration (update block and create block are\n * always run separately).\n */\nfunction getRenderFlags(view) {\n    return view.flags & 1 /* CreationMode */ ? 1 /* Create */ | 2 /* Update */ :\n        2 /* Update */;\n}\n//////////////////////////\n//// Element\n//////////////////////////\n/**\n * Create DOM element. The instruction must later be followed by `elementEnd()` call.\n *\n * @param index Index of the element in the data array\n * @param name Name of the DOM Node\n * @param attrs Statically bound set of attributes to be written into the DOM element on creation.\n * @param localRefs A set of local reference bindings on the element.\n *\n * Attributes and localRefs are passed as an array of strings where elements with an even index\n * hold an attribute name and elements with an odd index hold an attribute value, ex.:\n * ['id', 'warning5', 'class', 'alert']\n */\nfunction elementStart(index, name, attrs, localRefs) {\n    ngDevMode &&\n        assertEqual(currentView.bindingStartIndex, -1, 'elements should be created before any bindings');\n    var native = renderer.createElement(name);\n    var node = createLNode(index, 3 /* Element */, native, null);\n    if (attrs)\n        setUpAttributes(native, attrs);\n    appendChild(node.parent, native, currentView);\n    createDirectivesAndLocals(index, name, attrs, localRefs, null);\n    return native;\n}\nfunction createDirectivesAndLocals(index, name, attrs, localRefs, containerData) {\n    var node = previousOrParentNode;\n    if (firstTemplatePass) {\n        ngDevMode && assertDataInRange(index - 1);\n        node.tNode = tData[index] = createTNode(name, attrs || null, containerData);\n        cacheMatchingDirectivesForNode(node.tNode, currentView.tView, localRefs || null);\n    }\n    else {\n        instantiateDirectivesDirectly();\n    }\n    saveResolvedLocalsInData();\n}\n/**\n * On first template pass, we match each node against available directive selectors and save\n * the resulting defs in the correct instantiation order for subsequent change detection runs\n * (so dependencies are always created before the directives that inject them).\n */\nfunction cacheMatchingDirectivesForNode(tNode, tView, localRefs) {\n    // Please make sure to have explicit type for `exportsMap`. Inferred type triggers bug in tsickle.\n    var exportsMap = localRefs ? { '': -1 } : null;\n    var matches = tView.currentMatches = findDirectiveMatches(tNode);\n    if (matches) {\n        for (var i = 0; i < matches.length; i += 2) {\n            var def = matches[i];\n            var valueIndex = i + 1;\n            resolveDirective(def, valueIndex, matches, tView);\n            saveNameToExportMap(matches[valueIndex], def, exportsMap);\n        }\n    }\n    if (exportsMap)\n        cacheMatchingLocalNames(tNode, localRefs, exportsMap);\n}\n/** Matches the current node against all available selectors. */\nfunction findDirectiveMatches(tNode) {\n    var registry = currentView.tView.directiveRegistry;\n    var matches = null;\n    if (registry) {\n        for (var i = 0; i < registry.length; i++) {\n            var def = registry[i];\n            if (isNodeMatchingSelectorList(tNode, def.selectors)) {\n                if (def.template) {\n                    if (tNode.flags & 4096 /* isComponent */)\n                        throwMultipleComponentError(tNode);\n                    tNode.flags = 4096 /* isComponent */;\n                }\n                if (def.diPublic)\n                    def.diPublic(def);\n                (matches || (matches = [])).push(def, null);\n            }\n        }\n    }\n    return matches;\n}\nfunction resolveDirective(def, valueIndex, matches, tView) {\n    if (matches[valueIndex] === null) {\n        matches[valueIndex] = CIRCULAR$2;\n        var instance = def.factory();\n        (tView.directives || (tView.directives = [])).push(def);\n        return directiveCreate(matches[valueIndex] = tView.directives.length - 1, instance, def);\n    }\n    else if (matches[valueIndex] === CIRCULAR$2) {\n        // If we revisit this directive before it's resolved, we know it's circular\n        throwCyclicDependencyError(def.type);\n    }\n    return null;\n}\n/** Stores index of component's host element so it will be queued for view refresh during CD. */\nfunction queueComponentIndexForCheck(dirIndex) {\n    if (firstTemplatePass) {\n        (currentView.tView.components || (currentView.tView.components = [])).push(dirIndex, data.length - 1);\n    }\n}\n/** Stores index of directive and host element so it will be queued for binding refresh during CD.\n */\nfunction queueHostBindingForCheck(dirIndex) {\n    ngDevMode &&\n        assertEqual(firstTemplatePass, true, 'Should only be called in first template pass.');\n    (currentView.tView.hostBindings || (currentView.tView.hostBindings = [])).push(dirIndex, data.length - 1);\n}\n/** Sets the context for a ChangeDetectorRef to the given instance. */\nfunction initChangeDetectorIfExisting(injector, instance, view) {\n    if (injector && injector.changeDetectorRef != null) {\n        injector.changeDetectorRef._setComponentContext(view, instance);\n    }\n}\nfunction isComponent(tNode) {\n    return (tNode.flags & 4096 /* isComponent */) === 4096 /* isComponent */;\n}\n/**\n * This function instantiates the given directives.\n */\nfunction instantiateDirectivesDirectly() {\n    var tNode = previousOrParentNode.tNode;\n    var count = tNode.flags & 4095;\n    if (count > 0) {\n        var start = tNode.flags >> 13;\n        var end = start + count;\n        var tDirectives = currentView.tView.directives;\n        for (var i = start; i < end; i++) {\n            var def = tDirectives[i];\n            directiveCreate(i, def.factory(), def);\n        }\n    }\n}\n/** Caches local names and their matching directive indices for query and template lookups. */\nfunction cacheMatchingLocalNames(tNode, localRefs, exportsMap) {\n    if (localRefs) {\n        var localNames = tNode.localNames = [];\n        // Local names must be stored in tNode in the same order that localRefs are defined\n        // in the template to ensure the data is loaded in the same slots as their refs\n        // in the template (for template queries).\n        for (var i = 0; i < localRefs.length; i += 2) {\n            var index = exportsMap[localRefs[i + 1]];\n            if (index == null)\n                throw new Error(\"Export of name '\" + localRefs[i + 1] + \"' not found!\");\n            localNames.push(localRefs[i], index);\n        }\n    }\n}\n/**\n * Builds up an export map as directives are created, so local refs can be quickly mapped\n * to their directive instances.\n */\nfunction saveNameToExportMap(index, def, exportsMap) {\n    if (exportsMap) {\n        if (def.exportAs)\n            exportsMap[def.exportAs] = index;\n        if (def.template)\n            exportsMap[''] = index;\n    }\n}\n/**\n * Takes a list of local names and indices and pushes the resolved local variable values\n * to data[] in the same order as they are loaded in the template with load().\n */\nfunction saveResolvedLocalsInData() {\n    var localNames = previousOrParentNode.tNode.localNames;\n    if (localNames) {\n        for (var i = 0; i < localNames.length; i += 2) {\n            var index = localNames[i + 1];\n            var value = index === -1 ? previousOrParentNode.native : directives[index];\n            data.push(value);\n        }\n    }\n}\n/**\n * Gets TView from a template function or creates a new TView\n * if it doesn't already exist.\n *\n * @param template The template from which to get static data\n * @param directives Directive defs that should be saved on TView\n * @param pipes Pipe defs that should be saved on TView\n * @returns TView\n */\nfunction getOrCreateTView(template, directives, pipes) {\n    return template.ngPrivateData ||\n        (template.ngPrivateData = createTView(directives, pipes));\n}\n/** Creates a TView instance */\nfunction createTView(defs, pipes) {\n    return {\n        data: [],\n        directives: null,\n        firstTemplatePass: true,\n        initHooks: null,\n        checkHooks: null,\n        contentHooks: null,\n        contentCheckHooks: null,\n        viewHooks: null,\n        viewCheckHooks: null,\n        destroyHooks: null,\n        pipeDestroyHooks: null,\n        hostBindings: null,\n        components: null,\n        directiveRegistry: typeof defs === 'function' ? defs() : defs,\n        pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,\n        currentMatches: null\n    };\n}\nfunction setUpAttributes(native, attrs) {\n    ngDevMode && assertEqual(attrs.length % 2, 0, 'each attribute should have a key and a value');\n    var isProc = isProceduralRenderer(renderer);\n    for (var i = 0; i < attrs.length; i += 2) {\n        var attrName = attrs[i];\n        if (attrName !== NG_PROJECT_AS_ATTR_NAME) {\n            var attrVal = attrs[i + 1];\n            isProc ? renderer.setAttribute(native, attrName, attrVal) :\n                native.setAttribute(attrName, attrVal);\n        }\n    }\n}\nfunction createError(text, token) {\n    return new Error(\"Renderer: \" + text + \" [\" + stringify$1(token) + \"]\");\n}\n/**\n * Locates the host native element, used for bootstrapping existing nodes into rendering pipeline.\n *\n * @param elementOrSelector Render element or CSS selector to locate the element.\n */\nfunction locateHostElement(factory, elementOrSelector) {\n    ngDevMode && assertDataInRange(-1);\n    rendererFactory = factory;\n    var defaultRenderer = factory.createRenderer(null, null);\n    var rNode = typeof elementOrSelector === 'string' ?\n        (isProceduralRenderer(defaultRenderer) ?\n            defaultRenderer.selectRootElement(elementOrSelector) :\n            defaultRenderer.querySelector(elementOrSelector)) :\n        elementOrSelector;\n    if (ngDevMode && !rNode) {\n        if (typeof elementOrSelector === 'string') {\n            throw createError('Host node with selector not found:', elementOrSelector);\n        }\n        else {\n            throw createError('Host node is required:', elementOrSelector);\n        }\n    }\n    return rNode;\n}\n/**\n * Creates the host LNode.\n *\n * @param rNode Render host element.\n * @param def ComponentDef\n *\n * @returns LElementNode created\n */\nfunction hostElement(tag, rNode, def) {\n    resetApplicationState();\n    var node = createLNode(0, 3 /* Element */, rNode, createLView(-1, renderer, getOrCreateTView(def.template, def.directiveDefs, def.pipeDefs), null, null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */));\n    if (firstTemplatePass) {\n        node.tNode = createTNode(tag, null, null);\n        node.tNode.flags = 4096 /* isComponent */;\n        if (def.diPublic)\n            def.diPublic(def);\n        currentView.tView.directives = [def];\n    }\n    return node;\n}\n/**\n * Adds an event listener to the current node.\n *\n * If an output exists on one of the node's directives, it also subscribes to the output\n * and saves the subscription for later cleanup.\n *\n * @param eventName Name of the event\n * @param listenerFn The function to be called when event emits\n * @param useCapture Whether or not to use capture in event listener.\n */\nfunction listener(eventName, listenerFn, useCapture) {\n    if (useCapture === void 0) { useCapture = false; }\n    ngDevMode && assertPreviousIsParent();\n    var node = previousOrParentNode;\n    var native = node.native;\n    // In order to match current behavior, native DOM event listeners must be added for all\n    // events (including outputs).\n    var cleanupFns = cleanup || (cleanup = currentView.cleanup = []);\n    if (isProceduralRenderer(renderer)) {\n        var wrappedListener = wrapListenerWithDirtyLogic(currentView, listenerFn);\n        var cleanupFn = renderer.listen(native, eventName, wrappedListener);\n        cleanupFns.push(cleanupFn, null);\n    }\n    else {\n        var wrappedListener = wrapListenerWithDirtyAndDefault(currentView, listenerFn);\n        native.addEventListener(eventName, wrappedListener, useCapture);\n        cleanupFns.push(eventName, native, wrappedListener, useCapture);\n    }\n    var tNode = node.tNode;\n    if (tNode.outputs === undefined) {\n        // if we create TNode here, inputs must be undefined so we know they still need to be\n        // checked\n        tNode.outputs = generatePropertyAliases(node.tNode.flags, 1 /* Output */);\n    }\n    var outputs = tNode.outputs;\n    var outputData;\n    if (outputs && (outputData = outputs[eventName])) {\n        createOutput(outputData, listenerFn);\n    }\n}\n/**\n * Iterates through the outputs associated with a particular event name and subscribes to\n * each output.\n */\nfunction createOutput(outputs, listener) {\n    for (var i = 0; i < outputs.length; i += 2) {\n        ngDevMode && assertDataInRange(outputs[i], directives);\n        var subscription = directives[outputs[i]][outputs[i + 1]].subscribe(listener);\n        cleanup.push(subscription.unsubscribe, subscription);\n    }\n}\n/** Mark the end of the element. */\nfunction elementEnd() {\n    if (isParent) {\n        isParent = false;\n    }\n    else {\n        ngDevMode && assertHasParent();\n        previousOrParentNode = previousOrParentNode.parent;\n    }\n    ngDevMode && assertNodeType(previousOrParentNode, 3 /* Element */);\n    var queries = previousOrParentNode.queries;\n    queries && queries.addNode(previousOrParentNode);\n    queueLifecycleHooks(previousOrParentNode.tNode.flags, currentView);\n}\n/**\n * Updates the value of removes an attribute on an Element.\n *\n * @param number index The index of the element in the data array\n * @param name name The name of the attribute.\n * @param value value The attribute is removed when value is `null` or `undefined`.\n *                  Otherwise the attribute value is set to the stringified value.\n * @param sanitizer An optional function used to sanitize the value.\n */\nfunction elementAttribute(index, name, value, sanitizer) {\n    if (value !== NO_CHANGE) {\n        var element = data[index];\n        if (value == null) {\n            isProceduralRenderer(renderer) ? renderer.removeAttribute(element.native, name) :\n                element.native.removeAttribute(name);\n        }\n        else {\n            var strValue = sanitizer == null ? stringify$1(value) : sanitizer(value);\n            isProceduralRenderer(renderer) ? renderer.setAttribute(element.native, name, strValue) :\n                element.native.setAttribute(name, strValue);\n        }\n    }\n}\n/**\n * Update a property on an Element.\n *\n * If the property name also exists as an input property on one of the element's directives,\n * the component property will be set instead of the element property. This check must\n * be conducted at runtime so child components that add new @Inputs don't have to be re-compiled.\n *\n * @param index The index of the element to update in the data array\n * @param propName Name of property. Because it is going to DOM, this is not subject to\n *        renaming as part of minification.\n * @param value New value to write.\n * @param sanitizer An optional function used to sanitize the value.\n */\nfunction elementProperty(index, propName, value, sanitizer) {\n    if (value === NO_CHANGE)\n        return;\n    var node = data[index];\n    var tNode = node.tNode;\n    // if tNode.inputs is undefined, a listener has created outputs, but inputs haven't\n    // yet been checked\n    if (tNode && tNode.inputs === undefined) {\n        // mark inputs as checked\n        tNode.inputs = generatePropertyAliases(node.tNode.flags, 0 /* Input */);\n    }\n    var inputData = tNode && tNode.inputs;\n    var dataValue;\n    if (inputData && (dataValue = inputData[propName])) {\n        setInputsForProperty(dataValue, value);\n        markDirtyIfOnPush(node);\n    }\n    else {\n        // It is assumed that the sanitizer is only added when the compiler determines that the property\n        // is risky, so sanitization can be done without further checks.\n        value = sanitizer != null ? sanitizer(value) : value;\n        var native = node.native;\n        isProceduralRenderer(renderer) ? renderer.setProperty(native, propName, value) :\n            (native.setProperty ? native.setProperty(propName, value) :\n                native[propName] = value);\n    }\n}\n/**\n * Constructs a TNode object from the arguments.\n *\n * @param tagName\n * @param attrs\n * @param data\n * @param localNames A list of local names and their matching indices\n * @returns the TNode object\n */\nfunction createTNode(tagName, attrs, data) {\n    return {\n        flags: 0,\n        tagName: tagName,\n        attrs: attrs,\n        localNames: null,\n        initialInputs: undefined,\n        inputs: undefined,\n        outputs: undefined,\n        data: data\n    };\n}\n/**\n * Given a list of directive indices and minified input names, sets the\n * input properties on the corresponding directives.\n */\nfunction setInputsForProperty(inputs, value) {\n    for (var i = 0; i < inputs.length; i += 2) {\n        ngDevMode && assertDataInRange(inputs[i], directives);\n        directives[inputs[i]][inputs[i + 1]] = value;\n    }\n}\n/**\n * Consolidates all inputs or outputs of all directives on this logical node.\n *\n * @param number lNodeFlags logical node flags\n * @param Direction direction whether to consider inputs or outputs\n * @returns PropertyAliases|null aggregate of all properties if any, `null` otherwise\n */\nfunction generatePropertyAliases(tNodeFlags, direction) {\n    var count = tNodeFlags & 4095;\n    var propStore = null;\n    if (count > 0) {\n        var start = tNodeFlags >> 13;\n        var end = start + count;\n        var isInput = direction === 0;\n        var defs = currentView.tView.directives;\n        for (var i = start; i < end; i++) {\n            var directiveDef = defs[i];\n            var propertyAliasMap = isInput ? directiveDef.inputs : directiveDef.outputs;\n            for (var publicName in propertyAliasMap) {\n                if (propertyAliasMap.hasOwnProperty(publicName)) {\n                    propStore = propStore || {};\n                    var internalName = propertyAliasMap[publicName];\n                    var hasProperty = propStore.hasOwnProperty(publicName);\n                    hasProperty ? propStore[publicName].push(i, internalName) :\n                        (propStore[publicName] = [i, internalName]);\n                }\n            }\n        }\n    }\n    return propStore;\n}\n/**\n * Add or remove a class in a `classList` on a DOM element.\n *\n * This instruction is meant to handle the [class.foo]=\"exp\" case\n *\n * @param index The index of the element to update in the data array\n * @param className Name of class to toggle. Because it is going to DOM, this is not subject to\n *        renaming as part of minification.\n * @param value A value indicating if a given class should be added or removed.\n */\nfunction elementClassNamed(index, className, value) {\n    if (value !== NO_CHANGE) {\n        var lElement = data[index];\n        if (value) {\n            isProceduralRenderer(renderer) ? renderer.addClass(lElement.native, className) :\n                lElement.native.classList.add(className);\n        }\n        else {\n            isProceduralRenderer(renderer) ? renderer.removeClass(lElement.native, className) :\n                lElement.native.classList.remove(className);\n        }\n    }\n}\n/**\n * Set the `className` property on a DOM element.\n *\n * This instruction is meant to handle the `[class]=\"exp\"` usage.\n *\n * `elementClass` instruction writes the value to the \"element's\" `className` property.\n *\n * @param index The index of the element to update in the data array\n * @param value A value indicating a set of classes which should be applied. The method overrides\n *   any existing classes. The value is stringified (`toString`) before it is applied to the\n *   element.\n */\nfunction elementClass(index, value) {\n    if (value !== NO_CHANGE) {\n        // TODO: This is a naive implementation which simply writes value to the `className`. In the\n        // future\n        // we will add logic here which would work with the animation code.\n        var lElement = data[index];\n        isProceduralRenderer(renderer) ? renderer.setProperty(lElement.native, 'className', value) :\n            lElement.native['className'] = stringify$1(value);\n    }\n}\nfunction elementStyleNamed(index, styleName, value, suffixOrSanitizer) {\n    if (value !== NO_CHANGE) {\n        var lElement = data[index];\n        if (value == null) {\n            isProceduralRenderer(renderer) ?\n                renderer.removeStyle(lElement.native, styleName, RendererStyleFlags3.DashCase) :\n                lElement.native['style'].removeProperty(styleName);\n        }\n        else {\n            var strValue = typeof suffixOrSanitizer == 'function' ? suffixOrSanitizer(value) : stringify$1(value);\n            if (typeof suffixOrSanitizer == 'string')\n                strValue = strValue + suffixOrSanitizer;\n            isProceduralRenderer(renderer) ?\n                renderer.setStyle(lElement.native, styleName, strValue, RendererStyleFlags3.DashCase) :\n                lElement.native['style'].setProperty(styleName, strValue);\n        }\n    }\n}\n/**\n * Set the `style` property on a DOM element.\n *\n * This instruction is meant to handle the `[style]=\"exp\"` usage.\n *\n *\n * @param index The index of the element to update in the data array\n * @param value A value indicating if a given style should be added or removed.\n *   The expected shape of `value` is an object where keys are style names and the values\n *   are their corresponding values to set. If value is falsy than the style is remove. An absence\n *   of style does not cause that style to be removed. `NO_CHANGE` implies that no update should be\n *   performed.\n */\nfunction elementStyle(index, value) {\n    if (value !== NO_CHANGE) {\n        // TODO: This is a naive implementation which simply writes value to the `style`. In the future\n        // we will add logic here which would work with the animation code.\n        var lElement = data[index];\n        if (isProceduralRenderer(renderer)) {\n            renderer.setProperty(lElement.native, 'style', value);\n        }\n        else {\n            var style = lElement.native['style'];\n            for (var i = 0, keys = Object.keys(value); i < keys.length; i++) {\n                var styleName = keys[i];\n                var styleValue = value[styleName];\n                styleValue == null ? style.removeProperty(styleName) :\n                    style.setProperty(styleName, styleValue);\n            }\n        }\n    }\n}\n//////////////////////////\n//// Text\n//////////////////////////\n/**\n * Create static text node\n *\n * @param index Index of the node in the data array.\n * @param value Value to write. This value will be stringified.\n *   If value is not provided than the actual creation of the text node is delayed.\n */\nfunction text(index, value) {\n    ngDevMode &&\n        assertEqual(currentView.bindingStartIndex, -1, 'text nodes should be created before bindings');\n    var textNode = value != null ? createTextNode(value, renderer) : null;\n    var node = createLNode(index, 3 /* Element */, textNode);\n    // Text nodes are self closing.\n    isParent = false;\n    appendChild(node.parent, textNode, currentView);\n}\n/**\n * Create text node with binding\n * Bindings should be handled externally with the proper bind(1-8) method\n *\n * @param index Index of the node in the data array.\n * @param value Stringified value to write.\n */\nfunction textBinding(index, value) {\n    ngDevMode && assertDataInRange(index);\n    var existingNode = data[index];\n    ngDevMode && assertNotNull(existingNode, 'existing node');\n    if (existingNode.native) {\n        // If DOM node exists and value changed, update textContent\n        value !== NO_CHANGE &&\n            (isProceduralRenderer(renderer) ? renderer.setValue(existingNode.native, stringify$1(value)) :\n                existingNode.native.textContent = stringify$1(value));\n    }\n    else {\n        // Node was created but DOM node creation was delayed. Create and append now.\n        existingNode.native = createTextNode(value, renderer);\n        insertChild(existingNode, currentView);\n    }\n}\n//////////////////////////\n//// Directive\n//////////////////////////\n/**\n * Create a directive.\n *\n * NOTE: directives can be created in order other than the index order. They can also\n *       be retrieved before they are created in which case the value will be null.\n *\n * @param directive The directive instance.\n * @param directiveDef DirectiveDef object which contains information about the template.\n */\nfunction directiveCreate(index, directive, directiveDef) {\n    var instance = baseDirectiveCreate(index, directive, directiveDef);\n    ngDevMode && assertNotNull(previousOrParentNode.tNode, 'previousOrParentNode.tNode');\n    var tNode = previousOrParentNode.tNode;\n    var isComponent = directiveDef.template;\n    if (isComponent) {\n        addComponentLogic(index, directive, directiveDef);\n    }\n    if (firstTemplatePass) {\n        // Init hooks are queued now so ngOnInit is called in host components before\n        // any projected components.\n        queueInitHooks(index, directiveDef.onInit, directiveDef.doCheck, currentView.tView);\n        if (directiveDef.hostBindings)\n            queueHostBindingForCheck(index);\n    }\n    if (tNode && tNode.attrs) {\n        setInputsFromAttrs(index, instance, directiveDef.inputs, tNode);\n    }\n    return instance;\n}\nfunction addComponentLogic(index, instance, def) {\n    var tView = getOrCreateTView(def.template, def.directiveDefs, def.pipeDefs);\n    // Only component views should be added to the view tree directly. Embedded views are\n    // accessed through their containers because they may be removed / re-added later.\n    var hostView = addToViewTree(currentView, createLView(-1, rendererFactory.createRenderer(previousOrParentNode.native, def.rendererType), tView, null, null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */));\n    previousOrParentNode.data = hostView;\n    hostView.node = previousOrParentNode;\n    initChangeDetectorIfExisting(previousOrParentNode.nodeInjector, instance, hostView);\n    if (firstTemplatePass)\n        queueComponentIndexForCheck(index);\n}\n/**\n * A lighter version of directiveCreate() that is used for the root component\n *\n * This version does not contain features that we don't already support at root in\n * current Angular. Example: local refs and inputs on root component.\n */\nfunction baseDirectiveCreate(index, directive, directiveDef) {\n    ngDevMode &&\n        assertEqual(currentView.bindingStartIndex, -1, 'directives should be created before any bindings');\n    ngDevMode && assertPreviousIsParent();\n    Object.defineProperty(directive, NG_HOST_SYMBOL, { enumerable: false, value: previousOrParentNode });\n    if (directives == null)\n        currentView.directives = directives = [];\n    ngDevMode && assertDataNext(index, directives);\n    directives[index] = directive;\n    if (firstTemplatePass) {\n        var flags = previousOrParentNode.tNode.flags;\n        if ((flags & 4095 /* DirectiveCountMask */) === 0) {\n            // When the first directive is created:\n            // - save the index,\n            // - set the number of directives to 1\n            previousOrParentNode.tNode.flags =\n                index << 13 /* DirectiveStartingIndexShift */ | flags & 4096 /* isComponent */ | 1;\n        }\n        else {\n            // Only need to bump the size when subsequent directives are created\n            ngDevMode && assertNotEqual(flags & 4095 /* DirectiveCountMask */, 4095 /* DirectiveCountMask */, 'Reached the max number of directives');\n            previousOrParentNode.tNode.flags++;\n        }\n    }\n    else {\n        var diPublic = directiveDef.diPublic;\n        if (diPublic)\n            diPublic(directiveDef);\n    }\n    if (directiveDef.attributes != null && previousOrParentNode.type == 3 /* Element */) {\n        setUpAttributes(previousOrParentNode.native, directiveDef.attributes);\n    }\n    return directive;\n}\n/**\n * Sets initial input properties on directive instances from attribute data\n *\n * @param directiveIndex Index of the directive in directives array\n * @param instance Instance of the directive on which to set the initial inputs\n * @param inputs The list of inputs from the directive def\n * @param tNode The static data for this node\n */\nfunction setInputsFromAttrs(directiveIndex, instance, inputs, tNode) {\n    var initialInputData = tNode.initialInputs;\n    if (initialInputData === undefined || directiveIndex >= initialInputData.length) {\n        initialInputData = generateInitialInputs(directiveIndex, inputs, tNode);\n    }\n    var initialInputs = initialInputData[directiveIndex];\n    if (initialInputs) {\n        for (var i = 0; i < initialInputs.length; i += 2) {\n            instance[initialInputs[i]] = initialInputs[i + 1];\n        }\n    }\n}\n/**\n * Generates initialInputData for a node and stores it in the template's static storage\n * so subsequent template invocations don't have to recalculate it.\n *\n * initialInputData is an array containing values that need to be set as input properties\n * for directives on this node, but only once on creation. We need this array to support\n * the case where you set an @Input property of a directive using attribute-like syntax.\n * e.g. if you have a `name` @Input, you can set it once like this:\n *\n * <my-component name=\"Bess\"></my-component>\n *\n * @param directiveIndex Index to store the initial input data\n * @param inputs The list of inputs from the directive def\n * @param tNode The static data on this node\n */\nfunction generateInitialInputs(directiveIndex, inputs, tNode) {\n    var initialInputData = tNode.initialInputs || (tNode.initialInputs = []);\n    initialInputData[directiveIndex] = null;\n    var attrs = tNode.attrs;\n    for (var i = 0; i < attrs.length; i += 2) {\n        var attrName = attrs[i];\n        var minifiedInputName = inputs[attrName];\n        if (minifiedInputName !== undefined) {\n            var inputsToStore = initialInputData[directiveIndex] || (initialInputData[directiveIndex] = []);\n            inputsToStore.push(minifiedInputName, attrs[i + 1]);\n        }\n    }\n    return initialInputData;\n}\n//////////////////////////\n//// ViewContainer & View\n//////////////////////////\nfunction createLContainer(parentLNode, currentView, template) {\n    ngDevMode && assertNotNull(parentLNode, 'containers should have a parent');\n    return {\n        views: [],\n        nextIndex: 0,\n        // If the direct parent of the container is a view, its views will need to be added\n        // through insertView() when its parent view is being inserted:\n        renderParent: canInsertNativeNode(parentLNode, currentView) ? parentLNode : null,\n        template: template == null ? null : template,\n        next: null,\n        parent: currentView,\n        dynamicViewCount: 0,\n        queries: null\n    };\n}\n/**\n * Creates an LContainerNode.\n *\n * Only `LViewNodes` can go into `LContainerNodes`.\n *\n * @param index The index of the container in the data array\n * @param template Optional inline template\n * @param tagName The name of the container element, if applicable\n * @param attrs The attrs attached to the container, if applicable\n * @param localRefs A set of local reference bindings on the element.\n */\nfunction container(index, template, tagName, attrs, localRefs) {\n    ngDevMode && assertEqual(currentView.bindingStartIndex, -1, 'container nodes should be created before any bindings');\n    var currentParent = isParent ? previousOrParentNode : previousOrParentNode.parent;\n    var lContainer = createLContainer(currentParent, currentView, template);\n    var node = createLNode(index, 0 /* Container */, undefined, lContainer);\n    // Containers are added to the current view tree instead of their embedded views\n    // because views can be removed and re-inserted.\n    addToViewTree(currentView, node.data);\n    createDirectivesAndLocals(index, tagName || null, attrs, localRefs, []);\n    isParent = false;\n    ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);\n    var queries = node.queries;\n    if (queries) {\n        // check if a given container node matches\n        queries.addNode(node);\n        // prepare place for matching nodes from views inserted into a given container\n        lContainer.queries = queries.container();\n    }\n}\n/**\n * Sets a container up to receive views.\n *\n * @param index The index of the container in the data array\n */\nfunction containerRefreshStart(index) {\n    ngDevMode && assertDataInRange(index);\n    previousOrParentNode = data[index];\n    ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);\n    isParent = true;\n    previousOrParentNode.data.nextIndex = 0;\n    ngDevMode && assertSame(previousOrParentNode.native, undefined, \"the container's native element should not have been set yet.\");\n    if (!checkNoChangesMode) {\n        // We need to execute init hooks here so ngOnInit hooks are called in top level views\n        // before they are called in embedded views (for backwards compatibility).\n        executeInitHooks(currentView, currentView.tView, creationMode);\n    }\n}\n/**\n * Marks the end of the LContainerNode.\n *\n * Marking the end of LContainerNode is the time when to child Views get inserted or removed.\n */\nfunction containerRefreshEnd() {\n    if (isParent) {\n        isParent = false;\n    }\n    else {\n        ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);\n        ngDevMode && assertHasParent();\n        previousOrParentNode = previousOrParentNode.parent;\n    }\n    ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);\n    var container = previousOrParentNode;\n    container.native = undefined;\n    ngDevMode && assertNodeType(container, 0 /* Container */);\n    var nextIndex = container.data.nextIndex;\n    // remove extra views at the end of the container\n    while (nextIndex < container.data.views.length) {\n        removeView(container, nextIndex);\n    }\n}\nfunction refreshDynamicChildren() {\n    for (var current = currentView.child; current !== null; current = current.next) {\n        if (current.dynamicViewCount !== 0 && current.views) {\n            var container_1 = current;\n            for (var i = 0; i < container_1.views.length; i++) {\n                var view = container_1.views[i];\n                // The directives and pipes are not needed here as an existing view is only being refreshed.\n                renderEmbeddedTemplate(view, view.data.template, view.data.context, renderer);\n            }\n        }\n    }\n}\n/**\n * Looks for a view with a given view block id inside a provided LContainer.\n * Removes views that need to be deleted in the process.\n *\n * @param containerNode where to search for views\n * @param startIdx starting index in the views array to search from\n * @param viewBlockId exact view block id to look for\n * @returns index of a found view or -1 if not found\n */\nfunction scanForView(containerNode, startIdx, viewBlockId) {\n    var views = containerNode.data.views;\n    for (var i = startIdx; i < views.length; i++) {\n        var viewAtPositionId = views[i].data.id;\n        if (viewAtPositionId === viewBlockId) {\n            return views[i];\n        }\n        else if (viewAtPositionId < viewBlockId) {\n            // found a view that should not be at this position - remove\n            removeView(containerNode, i);\n        }\n        else {\n            // found a view with id grater than the one we are searching for\n            // which means that required view doesn't exist and can't be found at\n            // later positions in the views array - stop the search here\n            break;\n        }\n    }\n    return null;\n}\n/**\n * Marks the start of an embedded view.\n *\n * @param viewBlockId The ID of this view\n * @return boolean Whether or not this view is in creation mode\n */\nfunction embeddedViewStart(viewBlockId) {\n    var container = (isParent ? previousOrParentNode : previousOrParentNode.parent);\n    ngDevMode && assertNodeType(container, 0 /* Container */);\n    var lContainer = container.data;\n    var viewNode = scanForView(container, lContainer.nextIndex, viewBlockId);\n    if (viewNode) {\n        previousOrParentNode = viewNode;\n        ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);\n        isParent = true;\n        enterView(viewNode.data, viewNode);\n    }\n    else {\n        // When we create a new LView, we always reset the state of the instructions.\n        var newView = createLView(viewBlockId, renderer, getOrCreateEmbeddedTView(viewBlockId, container), null, null, 2 /* CheckAlways */);\n        if (lContainer.queries) {\n            newView.queries = lContainer.queries.enterView(lContainer.nextIndex);\n        }\n        enterView(newView, viewNode = createLNode(null, 2 /* View */, null, newView));\n    }\n    return getRenderFlags(viewNode.data);\n}\n/**\n * Initialize the TView (e.g. static data) for the active embedded view.\n *\n * Each embedded view needs to set the global tData variable to the static data for\n * that view. Otherwise, the view's static data for a particular node would overwrite\n * the static data for a node in the view above it with the same index (since it's in the\n * same template).\n *\n * @param viewIndex The index of the TView in TContainer\n * @param parent The parent container in which to look for the view's static data\n * @returns TView\n */\nfunction getOrCreateEmbeddedTView(viewIndex, parent) {\n    ngDevMode && assertNodeType(parent, 0 /* Container */);\n    var tContainer = parent.tNode.data;\n    if (viewIndex >= tContainer.length || tContainer[viewIndex] == null) {\n        var tView = currentView.tView;\n        tContainer[viewIndex] = createTView(tView.directiveRegistry, tView.pipeRegistry);\n    }\n    return tContainer[viewIndex];\n}\n/** Marks the end of an embedded view. */\nfunction embeddedViewEnd() {\n    refreshDirectives();\n    isParent = false;\n    var viewNode = previousOrParentNode = currentView.node;\n    var containerNode = previousOrParentNode.parent;\n    if (containerNode) {\n        ngDevMode && assertNodeType(viewNode, 2 /* View */);\n        ngDevMode && assertNodeType(containerNode, 0 /* Container */);\n        var lContainer = containerNode.data;\n        if (creationMode) {\n            // When projected nodes are going to be inserted, the renderParent of the dynamic container\n            // used by the ViewContainerRef must be set.\n            setRenderParentInProjectedNodes(lContainer.renderParent, viewNode);\n            // it is a new view, insert it into collection of views for a given container\n            insertView(containerNode, viewNode, lContainer.nextIndex);\n        }\n        lContainer.nextIndex++;\n    }\n    leaveView(currentView.parent);\n    ngDevMode && assertEqual(isParent, false, 'isParent');\n    ngDevMode && assertNodeType(previousOrParentNode, 2 /* View */);\n}\n/**\n * For nodes which are projected inside an embedded view, this function sets the renderParent\n * of their dynamic LContainerNode.\n * @param renderParent the renderParent of the LContainer which contains the embedded view.\n * @param viewNode the embedded view.\n */\nfunction setRenderParentInProjectedNodes(renderParent, viewNode) {\n    if (renderParent != null) {\n        var node = viewNode.child;\n        while (node) {\n            if (node.type === 1 /* Projection */) {\n                var nodeToProject = node.data.head;\n                var lastNodeToProject = node.data.tail;\n                while (nodeToProject) {\n                    if (nodeToProject.dynamicLContainerNode) {\n                        nodeToProject.dynamicLContainerNode.data.renderParent = renderParent;\n                    }\n                    nodeToProject = nodeToProject === lastNodeToProject ? null : nodeToProject.pNextOrParent;\n                }\n            }\n            node = node.next;\n        }\n    }\n}\n/////////////\n/**\n * Refreshes components by entering the component view and processing its bindings, queries, etc.\n *\n * @param directiveIndex\n * @param elementIndex\n */\nfunction componentRefresh(directiveIndex, elementIndex) {\n    ngDevMode && assertDataInRange(elementIndex);\n    var element = data[elementIndex];\n    ngDevMode && assertNodeType(element, 3 /* Element */);\n    ngDevMode && assertNotNull(element.data, \"Component's host node should have an LView attached.\");\n    var hostView = element.data;\n    // Only attached CheckAlways components or attached, dirty OnPush components should be checked\n    if (viewAttached(hostView) && hostView.flags & (2 /* CheckAlways */ | 4 /* Dirty */)) {\n        ngDevMode && assertDataInRange(directiveIndex, directives);\n        var def = currentView.tView.directives[directiveIndex];\n        detectChangesInternal(hostView, element, def, getDirectiveInstance(directives[directiveIndex]));\n    }\n}\n/** Returns a boolean for whether the view is attached */\nfunction viewAttached(view) {\n    return (view.flags & 8 /* Attached */) === 8 /* Attached */;\n}\n/**\n * Instruction to distribute projectable nodes among <ng-content> occurrences in a given template.\n * It takes all the selectors from the entire component's template and decides where\n * each projected node belongs (it re-distributes nodes among \"buckets\" where each \"bucket\" is\n * backed by a selector).\n *\n * This function requires CSS selectors to be provided in 2 forms: parsed (by a compiler) and text,\n * un-parsed form.\n *\n * The parsed form is needed for efficient matching of a node against a given CSS selector.\n * The un-parsed, textual form is needed for support of the ngProjectAs attribute.\n *\n * Having a CSS selector in 2 different formats is not ideal, but alternatives have even more\n * drawbacks:\n * - having only a textual form would require runtime parsing of CSS selectors;\n * - we can't have only a parsed as we can't re-construct textual form from it (as entered by a\n * template author).\n *\n * @param selectors A collection of parsed CSS selectors\n * @param rawSelectors A collection of CSS selectors in the raw, un-parsed form\n */\nfunction projectionDef(index, selectors, textSelectors) {\n    var noOfNodeBuckets = selectors ? selectors.length + 1 : 1;\n    var distributedNodes = new Array(noOfNodeBuckets);\n    for (var i = 0; i < noOfNodeBuckets; i++) {\n        distributedNodes[i] = [];\n    }\n    var componentNode = findComponentHost(currentView);\n    var componentChild = componentNode.child;\n    while (componentChild !== null) {\n        // execute selector matching logic if and only if:\n        // - there are selectors defined\n        // - a node has a tag name / attributes that can be matched\n        if (selectors && componentChild.tNode) {\n            var matchedIdx = matchingSelectorIndex(componentChild.tNode, selectors, textSelectors);\n            distributedNodes[matchedIdx].push(componentChild);\n        }\n        else {\n            distributedNodes[0].push(componentChild);\n        }\n        componentChild = componentChild.next;\n    }\n    ngDevMode && assertDataNext(index);\n    data[index] = distributedNodes;\n}\n/**\n * Updates the linked list of a projection node, by appending another linked list.\n *\n * @param projectionNode Projection node whose projected nodes linked list has to be updated\n * @param appendedFirst First node of the linked list to append.\n * @param appendedLast Last node of the linked list to append.\n */\nfunction appendToProjectionNode(projectionNode, appendedFirst, appendedLast) {\n    ngDevMode && assertEqual(!!appendedFirst, !!appendedLast, 'appendedFirst can be null if and only if appendedLast is also null');\n    if (!appendedLast) {\n        // nothing to append\n        return;\n    }\n    var projectionNodeData = projectionNode.data;\n    if (projectionNodeData.tail) {\n        projectionNodeData.tail.pNextOrParent = appendedFirst;\n    }\n    else {\n        projectionNodeData.head = appendedFirst;\n    }\n    projectionNodeData.tail = appendedLast;\n    appendedLast.pNextOrParent = projectionNode;\n}\n/**\n * Inserts previously re-distributed projected nodes. This instruction must be preceded by a call\n * to the projectionDef instruction.\n *\n * @param nodeIndex\n * @param localIndex - index under which distribution of projected nodes was memorized\n * @param selectorIndex - 0 means <ng-content> without any selector\n * @param attrs - attributes attached to the ng-content node, if present\n */\nfunction projection(nodeIndex, localIndex, selectorIndex, attrs) {\n    if (selectorIndex === void 0) { selectorIndex = 0; }\n    var node = createLNode(nodeIndex, 1 /* Projection */, null, { head: null, tail: null });\n    if (node.tNode == null) {\n        node.tNode = createTNode(null, attrs || null, null);\n    }\n    isParent = false; // self closing\n    var currentParent = node.parent;\n    // re-distribution of projectable nodes is memorized on a component's view level\n    var componentNode = findComponentHost(currentView);\n    // make sure that nodes to project were memorized\n    var nodesForSelector = componentNode.data.data[localIndex][selectorIndex];\n    // build the linked list of projected nodes:\n    for (var i = 0; i < nodesForSelector.length; i++) {\n        var nodeToProject = nodesForSelector[i];\n        if (nodeToProject.type === 1 /* Projection */) {\n            var previouslyProjected = nodeToProject.data;\n            appendToProjectionNode(node, previouslyProjected.head, previouslyProjected.tail);\n        }\n        else {\n            appendToProjectionNode(node, nodeToProject, nodeToProject);\n        }\n    }\n    if (canInsertNativeNode(currentParent, currentView)) {\n        ngDevMode && assertNodeType(currentParent, 3 /* Element */);\n        // process each node in the list of projected nodes:\n        var nodeToProject = node.data.head;\n        var lastNodeToProject = node.data.tail;\n        while (nodeToProject) {\n            appendProjectedNode(nodeToProject, currentParent, currentView);\n            nodeToProject = nodeToProject === lastNodeToProject ? null : nodeToProject.pNextOrParent;\n        }\n    }\n}\n/**\n * Given a current view, finds the nearest component's host (LElement).\n *\n * @param lView LView for which we want a host element node\n * @returns The host node\n */\nfunction findComponentHost(lView) {\n    var viewRootLNode = lView.node;\n    while (viewRootLNode.type === 2 /* View */) {\n        ngDevMode && assertNotNull(lView.parent, 'lView.parent');\n        lView = lView.parent;\n        viewRootLNode = lView.node;\n    }\n    ngDevMode && assertNodeType(viewRootLNode, 3 /* Element */);\n    ngDevMode && assertNotNull(viewRootLNode.data, 'node.data');\n    return viewRootLNode;\n}\n/**\n * Adds a LView or a LContainer to the end of the current view tree.\n *\n * This structure will be used to traverse through nested views to remove listeners\n * and call onDestroy callbacks.\n *\n * @param currentView The view where LView or LContainer should be added\n * @param state The LView or LContainer to add to the view tree\n * @returns The state passed in\n */\nfunction addToViewTree(currentView, state) {\n    currentView.tail ? (currentView.tail.next = state) : (currentView.child = state);\n    currentView.tail = state;\n    return state;\n}\n///////////////////////////////\n//// Change detection\n///////////////////////////////\n/** If node is an OnPush component, marks its LView dirty. */\nfunction markDirtyIfOnPush(node) {\n    // Because data flows down the component tree, ancestors do not need to be marked dirty\n    if (node.data && !(node.data.flags & 2 /* CheckAlways */)) {\n        node.data.flags |= 4 /* Dirty */;\n    }\n}\n/**\n * Wraps an event listener so its host view and its ancestor views will be marked dirty\n * whenever the event fires. Necessary to support OnPush components.\n */\nfunction wrapListenerWithDirtyLogic(view, listenerFn) {\n    return function (e) {\n        markViewDirty(view);\n        return listenerFn(e);\n    };\n}\n/**\n * Wraps an event listener so its host view and its ancestor views will be marked dirty\n * whenever the event fires. Also wraps with preventDefault behavior.\n */\nfunction wrapListenerWithDirtyAndDefault(view, listenerFn) {\n    return function wrapListenerIn_markViewDirty(e) {\n        markViewDirty(view);\n        if (listenerFn(e) === false) {\n            e.preventDefault();\n            // Necessary for legacy browsers that don't support preventDefault (e.g. IE)\n            e.returnValue = false;\n        }\n    };\n}\n/** Marks current view and all ancestors dirty */\nfunction markViewDirty(view) {\n    var currentView = view;\n    while (currentView.parent != null) {\n        currentView.flags |= 4 /* Dirty */;\n        currentView = currentView.parent;\n    }\n    currentView.flags |= 4 /* Dirty */;\n    ngDevMode && assertNotNull(currentView.context, 'rootContext');\n    scheduleTick(currentView.context);\n}\n/**\n * Used to schedule change detection on the whole application.\n *\n * Unlike `tick`, `scheduleTick` coalesces multiple calls into one change detection run.\n * It is usually called indirectly by calling `markDirty` when the view needs to be\n * re-rendered.\n *\n * Typically `scheduleTick` uses `requestAnimationFrame` to coalesce multiple\n * `scheduleTick` requests. The scheduling function can be overridden in\n * `renderComponent`'s `scheduler` option.\n */\nfunction scheduleTick(rootContext) {\n    if (rootContext.clean == _CLEAN_PROMISE) {\n        var res_1;\n        rootContext.clean = new Promise(function (r) { return res_1 = r; });\n        rootContext.scheduler(function () {\n            tick(rootContext.component);\n            res_1(null);\n            rootContext.clean = _CLEAN_PROMISE;\n        });\n    }\n}\n/**\n * Used to perform change detection on the whole application.\n *\n * This is equivalent to `detectChanges`, but invoked on root component. Additionally, `tick`\n * executes lifecycle hooks and conditionally checks components based on their\n * `ChangeDetectionStrategy` and dirtiness.\n *\n * The preferred way to trigger change detection is to call `markDirty`. `markDirty` internally\n * schedules `tick` using a scheduler in order to coalesce multiple `markDirty` calls into a\n * single change detection run. By default, the scheduler is `requestAnimationFrame`, but can\n * be changed when calling `renderComponent` and providing the `scheduler` option.\n */\nfunction tick(component) {\n    var rootView = getRootView(component);\n    var rootComponent = rootView.context.component;\n    var hostNode = _getComponentHostLElementNode(rootComponent);\n    ngDevMode && assertNotNull(hostNode.data, 'Component host node should be attached to an LView');\n    renderComponentOrTemplate(hostNode, rootView, rootComponent);\n}\n/**\n * Retrieve the root view from any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param component any component\n */\nfunction getRootView(component) {\n    ngDevMode && assertNotNull(component, 'component');\n    var lElementNode = _getComponentHostLElementNode(component);\n    var lView = lElementNode.view;\n    while (lView.parent) {\n        lView = lView.parent;\n    }\n    return lView;\n}\n/**\n * Synchronously perform change detection on a component (and possibly its sub-components).\n *\n * This function triggers change detection in a synchronous way on a component. There should\n * be very little reason to call this function directly since a preferred way to do change\n * detection is to {@link markDirty} the component and wait for the scheduler to call this method\n * at some future point in time. This is because a single user action often results in many\n * components being invalidated and calling change detection on each component synchronously\n * would be inefficient. It is better to wait until all components are marked as dirty and\n * then perform single change detection across all of the components\n *\n * @param component The component which the change detection should be performed on.\n */\nfunction detectChanges(component) {\n    var hostNode = _getComponentHostLElementNode(component);\n    ngDevMode && assertNotNull(hostNode.data, 'Component host node should be attached to an LView');\n    var componentIndex = hostNode.tNode.flags >> 13;\n    var def = hostNode.view.tView.directives[componentIndex];\n    detectChangesInternal(hostNode.data, hostNode, def, component);\n}\n/**\n * Checks the change detector and its children, and throws if any changes are detected.\n *\n * This is used in development mode to verify that running change detection doesn't\n * introduce other changes.\n */\nfunction checkNoChanges(component) {\n    checkNoChangesMode = true;\n    try {\n        detectChanges(component);\n    }\n    finally {\n        checkNoChangesMode = false;\n    }\n}\n/** Checks the view of the component provided. Does not gate on dirty checks or execute doCheck. */\nfunction detectChangesInternal(hostView, hostNode, def, component) {\n    var oldView = enterView(hostView, hostNode);\n    var template = def.template;\n    try {\n        template(getRenderFlags(hostView), component);\n        refreshDirectives();\n        refreshDynamicChildren();\n    }\n    finally {\n        leaveView(oldView);\n    }\n}\n/**\n * Mark the component as dirty (needing change detection).\n *\n * Marking a component dirty will schedule a change detection on this\n * component at some point in the future. Marking an already dirty\n * component as dirty is a noop. Only one outstanding change detection\n * can be scheduled per component tree. (Two components bootstrapped with\n * separate `renderComponent` will have separate schedulers)\n *\n * When the root component is bootstrapped with `renderComponent`, a scheduler\n * can be provided.\n *\n * @param component Component to mark as dirty.\n */\nfunction markDirty(component) {\n    ngDevMode && assertNotNull(component, 'component');\n    var lElementNode = _getComponentHostLElementNode(component);\n    markViewDirty(lElementNode.view);\n}\n/** A special value which designates that a value has not changed. */\nvar NO_CHANGE = {};\n/**\n *  Initializes the binding start index. Will get inlined.\n *\n *  This function must be called before any binding related function is called\n *  (ie `bind()`, `interpolationX()`, `pureFunctionX()`)\n */\nfunction initBindings() {\n    ngDevMode && assertEqual(currentView.bindingStartIndex, -1, 'Binding start index should only be set once, when null');\n    ngDevMode && assertEqual(currentView.bindingIndex, -1, 'Binding index should not yet be set ' + currentView.bindingIndex);\n    currentView.bindingIndex = currentView.bindingStartIndex = data.length;\n}\n/**\n * Creates a single value binding.\n *\n * @param value Value to diff\n */\nfunction bind(value) {\n    if (currentView.bindingStartIndex < 0) {\n        initBindings();\n        return data[currentView.bindingIndex++] = value;\n    }\n    var changed = value !== NO_CHANGE && isDifferent(data[currentView.bindingIndex], value);\n    if (changed) {\n        throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, data[currentView.bindingIndex], value);\n        data[currentView.bindingIndex] = value;\n    }\n    currentView.bindingIndex++;\n    return changed ? value : NO_CHANGE;\n}\n/**\n * Create interpolation bindings with a variable number of expressions.\n *\n * If there are 1 to 8 expressions `interpolation1()` to `interpolation8()` should be used instead.\n * Those are faster because there is no need to create an array of expressions and iterate over it.\n *\n * `values`:\n * - has static text at even indexes,\n * - has evaluated expressions at odd indexes.\n *\n * Returns the concatenated string when any of the arguments changes, `NO_CHANGE` otherwise.\n */\nfunction interpolationV(values) {\n    ngDevMode && assertLessThan(2, values.length, 'should have at least 3 values');\n    ngDevMode && assertEqual(values.length % 2, 1, 'should have an odd number of values');\n    var different = false;\n    for (var i = 1; i < values.length; i += 2) {\n        // Check if bindings (odd indexes) have changed\n        bindingUpdated(values[i]) && (different = true);\n    }\n    if (!different) {\n        return NO_CHANGE;\n    }\n    // Build the updated content\n    var content = values[0];\n    for (var i = 1; i < values.length; i += 2) {\n        content += stringify$1(values[i]) + values[i + 1];\n    }\n    return content;\n}\n/**\n * Creates an interpolation binding with 1 expression.\n *\n * @param prefix static value used for concatenation only.\n * @param v0 value checked for change.\n * @param suffix static value used for concatenation only.\n */\nfunction interpolation1(prefix, v0, suffix) {\n    var different = bindingUpdated(v0);\n    return different ? prefix + stringify$1(v0) + suffix : NO_CHANGE;\n}\n/** Creates an interpolation binding with 2 expressions. */\nfunction interpolation2(prefix, v0, i0, v1, suffix) {\n    var different = bindingUpdated2(v0, v1);\n    return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + suffix : NO_CHANGE;\n}\n/** Creates an interpolation bindings with 3 expressions. */\nfunction interpolation3(prefix, v0, i0, v1, i1, v2, suffix) {\n    var different = bindingUpdated2(v0, v1);\n    different = bindingUpdated(v2) || different;\n    return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + suffix :\n        NO_CHANGE;\n}\n/** Create an interpolation binding with 4 expressions. */\nfunction interpolation4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) +\n            suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 5 expressions. */\nfunction interpolation5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated(v4) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 6 expressions. */\nfunction interpolation6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated2(v4, v5) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + i4 + stringify$1(v5) + suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 7 expressions. */\nfunction interpolation7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated2(v4, v5) || different;\n    different = bindingUpdated(v6) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + suffix :\n        NO_CHANGE;\n}\n/** Creates an interpolation binding with 8 expressions. */\nfunction interpolation8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix) {\n    var different = bindingUpdated4(v0, v1, v2, v3);\n    different = bindingUpdated4(v4, v5, v6, v7) || different;\n    return different ?\n        prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n            stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + i6 + stringify$1(v7) + suffix :\n        NO_CHANGE;\n}\n/** Store a value in the `data` at a given `index`. */\nfunction store(index, value) {\n    // We don't store any static data for local variables, so the first time\n    // we see the template, we should store as null to avoid a sparse array\n    if (index >= tData.length) {\n        tData[index] = null;\n    }\n    data[index] = value;\n}\n/** Retrieves a value from the `data`. */\nfunction load(index) {\n    ngDevMode && assertDataInRange(index);\n    return data[index];\n}\n/** Retrieves a value from the `directives` array. */\nfunction loadDirective(index) {\n    ngDevMode && assertNotNull(directives, 'Directives array should be defined if reading a dir.');\n    ngDevMode && assertDataInRange(index, directives);\n    return directives[index];\n}\n/** Gets the current binding value and increments the binding index. */\nfunction consumeBinding() {\n    ngDevMode && assertDataInRange(currentView.bindingIndex);\n    ngDevMode &&\n        assertNotEqual(data[currentView.bindingIndex], NO_CHANGE, 'Stored value should never be NO_CHANGE.');\n    return data[currentView.bindingIndex++];\n}\n/** Updates binding if changed, then returns whether it was updated. */\nfunction bindingUpdated(value) {\n    ngDevMode && assertNotEqual(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');\n    if (currentView.bindingStartIndex < 0) {\n        initBindings();\n    }\n    else if (isDifferent(data[currentView.bindingIndex], value)) {\n        throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, data[currentView.bindingIndex], value);\n    }\n    else {\n        currentView.bindingIndex++;\n        return false;\n    }\n    data[currentView.bindingIndex++] = value;\n    return true;\n}\n/** Updates binding if changed, then returns the latest value. */\nfunction checkAndUpdateBinding$1(value) {\n    bindingUpdated(value);\n    return value;\n}\n/** Updates 2 bindings if changed, then returns whether either was updated. */\nfunction bindingUpdated2(exp1, exp2) {\n    var different = bindingUpdated(exp1);\n    return bindingUpdated(exp2) || different;\n}\n/** Updates 4 bindings if changed, then returns whether any was updated. */\nfunction bindingUpdated4(exp1, exp2, exp3, exp4) {\n    var different = bindingUpdated2(exp1, exp2);\n    return bindingUpdated2(exp3, exp4) || different;\n}\nfunction getTView() {\n    return currentView.tView;\n}\nfunction getDirectiveInstance(instanceOrArray) {\n    // Directives with content queries store an array in directives[directiveIndex]\n    // with the instance as the first index\n    return Array.isArray(instanceOrArray) ? instanceOrArray[0] : instanceOrArray;\n}\nfunction assertPreviousIsParent() {\n    assertEqual(isParent, true, 'previousOrParentNode should be a parent');\n}\nfunction assertHasParent() {\n    assertNotNull(previousOrParentNode.parent, 'previousOrParentNode should have a parent');\n}\nfunction assertDataInRange(index, arr) {\n    if (arr == null)\n        arr = data;\n    assertLessThan(index, arr ? arr.length : 0, 'index expected to be a valid data index');\n}\nfunction assertDataNext(index, arr) {\n    if (arr == null)\n        arr = data;\n    assertEqual(arr.length, index, \"index \" + index + \" expected to be at the end of arr (length \" + arr.length + \")\");\n}\nfunction _getComponentHostLElementNode(component) {\n    ngDevMode && assertNotNull(component, 'expecting component got null');\n    var lElementNode = component[NG_HOST_SYMBOL];\n    ngDevMode && assertNotNull(component, 'object is not a component');\n    return lElementNode;\n}\nvar CLEAN_PROMISE = _CLEAN_PROMISE;\nvar ROOT_DIRECTIVE_INDICES = _ROOT_DIRECTIVE_INDICES;\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ViewRef$1 = /** @class */ (function () {\n    function ViewRef(_view, context) {\n        this._view = _view;\n        this.context = context;\n    }\n    /** @internal */\n    ViewRef.prototype._setComponentContext = function (view, context) {\n        this._view = view;\n        this.context = context;\n    };\n    ViewRef.prototype.destroy = function () {  };\n    ViewRef.prototype.onDestroy = function (callback) {  };\n    /**\n     * Marks a view and all of its ancestors dirty.\n     *\n     * It also triggers change detection by calling `scheduleTick` internally, which coalesces\n     * multiple `markForCheck` calls to into one change detection run.\n     *\n     * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is\n     * checked when it needs to be re-rendered but the two normal triggers haven't marked it\n     * dirty (i.e. inputs haven't changed and events haven't fired in the view).\n     *\n     * <!-- TODO: Add a link to a chapter on OnPush components -->\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * ```typescript\n     * @Component({\n     *   selector: 'my-app',\n     *   template: `Number of ticks: {{numberOfTicks}}`\n     *   changeDetection: ChangeDetectionStrategy.OnPush,\n     * })\n     * class AppComponent {\n     *   numberOfTicks = 0;\n     *\n     *   constructor(private ref: ChangeDetectorRef) {\n     *     setInterval(() => {\n     *       this.numberOfTicks++;\n     *       // the following is required, otherwise the view will not be updated\n     *       this.ref.markForCheck();\n     *     }, 1000);\n     *   }\n     * }\n     * ```\n     */\n    ViewRef.prototype.markForCheck = function () { markViewDirty(this._view); };\n    /**\n     * Detaches the view from the change detection tree.\n     *\n     * Detached views will not be checked during change detection runs until they are\n     * re-attached, even if they are dirty. `detach` can be used in combination with\n     * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change\n     * detection checks.\n     *\n     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n     * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * The following example defines a component with a large list of readonly data.\n     * Imagine the data changes constantly, many times per second. For performance reasons,\n     * we want to check and update the list every five seconds. We can do that by detaching\n     * the component's change detector and doing a local check every five seconds.\n     *\n     * ```typescript\n     * class DataProvider {\n     *   // in a real application the returned data will be different every time\n     *   get data() {\n     *     return [1,2,3,4,5];\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'giant-list',\n     *   template: `\n     *     <li *ngFor=\"let d of dataProvider.data\">Data {{d}}</li>\n     *   `,\n     * })\n     * class GiantList {\n     *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {\n     *     ref.detach();\n     *     setInterval(() => {\n     *       this.ref.detectChanges();\n     *     }, 5000);\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'app',\n     *   providers: [DataProvider],\n     *   template: `\n     *     <giant-list><giant-list>\n     *   `,\n     * })\n     * class App {\n     * }\n     * ```\n     */\n    ViewRef.prototype.detach = function () { this._view.flags &= ~8 /* Attached */; };\n    /**\n     * Re-attaches a view to the change detection tree.\n     *\n     * This can be used to re-attach views that were previously detached from the tree\n     * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.\n     *\n     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * The following example creates a component displaying `live` data. The component will detach\n     * its change detector from the main change detector tree when the component's live property\n     * is set to false.\n     *\n     * ```typescript\n     * class DataProvider {\n     *   data = 1;\n     *\n     *   constructor() {\n     *     setInterval(() => {\n     *       this.data = this.data * 2;\n     *     }, 500);\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'live-data',\n     *   inputs: ['live'],\n     *   template: 'Data: {{dataProvider.data}}'\n     * })\n     * class LiveData {\n     *   constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}\n     *\n     *   set live(value) {\n     *     if (value) {\n     *       this.ref.reattach();\n     *     } else {\n     *       this.ref.detach();\n     *     }\n     *   }\n     * }\n     *\n     * @Component({\n     *   selector: 'my-app',\n     *   providers: [DataProvider],\n     *   template: `\n     *     Live Update: <input type=\"checkbox\" [(ngModel)]=\"live\">\n     *     <live-data [live]=\"live\"><live-data>\n     *   `,\n     * })\n     * class AppComponent {\n     *   live = true;\n     * }\n     * ```\n     */\n    ViewRef.prototype.reattach = function () { this._view.flags |= 8 /* Attached */; };\n    /**\n     * Checks the view and its children.\n     *\n     * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement\n     * local change detection checks.\n     *\n     * <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->\n     * <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->\n     *\n     * @usageNotes\n     * ### Example\n     *\n     * The following example defines a component with a large list of readonly data.\n     * Imagine, the data changes constantly, many times per second. For performance reasons,\n     * we want to check and update the list every five seconds.\n     *\n     * We can do that by detaching the component's change detector and doing a local change detection\n     * check every five seconds.\n     *\n     * See {@link ChangeDetectorRef#detach detach} for more information.\n     */\n    ViewRef.prototype.detectChanges = function () { detectChanges(this.context); };\n    /**\n     * Checks the change detector and its children, and throws if any changes are detected.\n     *\n     * This is used in development mode to verify that running change detection doesn't\n     * introduce other changes.\n     */\n    ViewRef.prototype.checkNoChanges = function () { checkNoChanges(this.context); };\n    return ViewRef;\n}());\nvar EmbeddedViewRef$1 = /** @class */ (function (_super) {\n    __extends(EmbeddedViewRef, _super);\n    function EmbeddedViewRef(viewNode, template, context) {\n        var _this = _super.call(this, viewNode.data, context) || this;\n        _this._lViewNode = viewNode;\n        return _this;\n    }\n    return EmbeddedViewRef;\n}(ViewRef$1));\n/**\n * Creates a ViewRef bundled with destroy functionality.\n *\n * @param context The context for this view\n * @returns The ViewRef\n */\nfunction createViewRef(view, context) {\n    // TODO: add detectChanges back in when implementing ChangeDetectorRef.detectChanges\n    return addDestroyable(new ViewRef$1(view, context));\n}\n/**\n * Decorates an object with destroy logic (implementing the DestroyRef interface)\n * and returns the enhanced object.\n *\n * @param obj The object to decorate\n * @returns The object with destroy logic\n */\nfunction addDestroyable(obj) {\n    var destroyFn = null;\n    obj.destroyed = false;\n    obj.destroy = function () {\n        destroyFn && destroyFn.forEach(function (fn) { return fn(); });\n        this.destroyed = true;\n    };\n    obj.onDestroy = function (fn) { return (destroyFn || (destroyFn = [])).push(fn); };\n    return obj;\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 * Bootstraps a component, then creates and returns a `ComponentRef` for that component.\n *\n * @param componentType Component to bootstrap\n * @param options Optional parameters which control bootstrapping\n */\n\n// TODO: A hack to not pull in the NullInjector from @angular/core.\n\n/**\n * Bootstraps a Component into an existing host element and returns an instance\n * of the component.\n *\n * Use this function to bootstrap a component into the DOM tree. Each invocation\n * of this function will create a separate tree of components, injectors and\n * change detection cycles and lifetimes. To dynamically insert a new component\n * into an existing tree such that it shares the same injection, change detection\n * and object lifetime, use {@link ViewContainer#createComponent}.\n *\n * @param componentType Component to bootstrap\n * @param options Optional parameters which control bootstrapping\n */\nfunction renderComponent(componentType /* Type as workaround for: Microsoft/TypeScript/issues/4881 */, opts) {\n    if (opts === void 0) { opts = {}; }\n    ngDevMode && assertComponentType(componentType);\n    var rendererFactory = opts.rendererFactory || domRendererFactory3;\n    var componentDef = componentType.ngComponentDef;\n    if (componentDef.type != componentType)\n        componentDef.type = componentType;\n    var component;\n    // The first index of the first selector is the tag name.\n    var componentTag = componentDef.selectors[0][0];\n    var hostNode = locateHostElement(rendererFactory, opts.host || componentTag);\n    var rootContext = {\n        // Incomplete initialization due to circular reference.\n        component: null,\n        scheduler: opts.scheduler || requestAnimationFrame.bind(window),\n        clean: CLEAN_PROMISE,\n    };\n    var rootView = createLView(-1, rendererFactory.createRenderer(hostNode, componentDef.rendererType), createTView(null, null), null, rootContext, componentDef.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */);\n    rootView.injector = opts.injector || null;\n    var oldView = enterView(rootView, null);\n    var elementNode;\n    try {\n        if (rendererFactory.begin)\n            rendererFactory.begin();\n        // Create element node at index 0 in data array\n        elementNode = hostElement(componentTag, hostNode, componentDef);\n        // Create directive instance with factory() and store at index 0 in directives array\n        component = rootContext.component =\n            baseDirectiveCreate(0, componentDef.factory(), componentDef);\n        initChangeDetectorIfExisting(elementNode.nodeInjector, component, elementNode.data);\n        opts.hostFeatures && opts.hostFeatures.forEach(function (feature) { return feature(component, componentDef); });\n        executeInitAndContentHooks();\n        setHostBindings(ROOT_DIRECTIVE_INDICES);\n        detectChangesInternal(elementNode.data, elementNode, componentDef, component);\n    }\n    finally {\n        leaveView(oldView);\n        if (rendererFactory.end)\n            rendererFactory.end();\n    }\n    return component;\n}\n/**\n * Used to enable lifecycle hooks on the root component.\n *\n * Include this feature when calling `renderComponent` if the root component\n * you are rendering has lifecycle hooks defined. Otherwise, the hooks won't\n * be called properly.\n *\n * Example:\n *\n * ```\n * renderComponent(AppComponent, {features: [RootLifecycleHooks]});\n * ```\n */\n\n/**\n * Retrieve the root context for any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param component any component\n */\nfunction getRootContext(component) {\n    var rootContext = getRootView(component).context;\n    ngDevMode && assertNotNull(rootContext, 'rootContext');\n    return rootContext;\n}\n/**\n * Retrieve the host element of the component.\n *\n * Use this function to retrieve the host element of the component. The host\n * element is the element which the component is associated with.\n *\n * @param component Component for which the host element should be retrieved.\n */\n\n/**\n * Retrieves the rendered text for a given component.\n *\n * This function retrieves the host element of a component and\n * and then returns the `textContent` for that element. This implies\n * that the text returned will include re-projected content of\n * the component as well.\n *\n * @param component The component to return the content text for.\n */\n\n/**\n * Wait on component until it is rendered.\n *\n * This function returns a `Promise` which is resolved when the component's\n * change detection is executed. This is determined by finding the scheduler\n * associated with the `component`'s render tree and waiting until the scheduler\n * flushes. If nothing is scheduled, the function returns a resolved promise.\n *\n * Example:\n * ```\n * await whenRendered(myComponent);\n * ```\n *\n * @param component Component to wait upon\n * @returns Promise which resolves when the component is rendered.\n */\nfunction whenRendered(component) {\n    return getRootContext(component).clean;\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 * If a directive is diPublic, bloomAdd sets a property on the instance with this constant as\n * the key and the directive's unique ID as the value. This allows us to map directives to their\n * bloom filter bit for DI.\n */\nvar NG_ELEMENT_ID = '__NG_ELEMENT_ID__';\n/**\n * The number of slots in each bloom filter (used by DI). The larger this number, the fewer\n * directives that will share slots, and thus, the fewer false positives when checking for\n * the existence of a directive.\n */\nvar BLOOM_SIZE = 256;\n/** Counter used to generate unique IDs for directives. */\nvar nextNgElementId = 0;\n/**\n * Registers this directive as present in its node's injector by flipping the directive's\n * corresponding bit in the injector's bloom filter.\n *\n * @param injector The node injector in which the directive should be registered\n * @param type The directive to register\n */\nfunction bloomAdd(injector, type) {\n    var id = type[NG_ELEMENT_ID];\n    // Set a unique ID on the directive type, so if something tries to inject the directive,\n    // we can easily retrieve the ID and hash it into the bloom bit that should be checked.\n    if (id == null) {\n        id = type[NG_ELEMENT_ID] = nextNgElementId++;\n    }\n    // We only have BLOOM_SIZE (256) slots in our bloom filter (8 buckets * 32 bits each),\n    // so all unique IDs must be modulo-ed into a number from 0 - 255 to fit into the filter.\n    // This means that after 255, some directives will share slots, leading to some false positives\n    // when checking for a directive's presence.\n    var bloomBit = id % BLOOM_SIZE;\n    // Create a mask that targets the specific bit associated with the directive.\n    // JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding\n    // to bit positions 0 - 31 in a 32 bit integer.\n    var mask = 1 << bloomBit;\n    // Use the raw bloomBit number to determine which bloom filter bucket we should check\n    // e.g: bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc\n    if (bloomBit < 128) {\n        // Then use the mask to flip on the bit (0-31) associated with the directive in that bucket\n        bloomBit < 64 ? (bloomBit < 32 ? (injector.bf0 |= mask) : (injector.bf1 |= mask)) :\n            (bloomBit < 96 ? (injector.bf2 |= mask) : (injector.bf3 |= mask));\n    }\n    else {\n        bloomBit < 192 ? (bloomBit < 160 ? (injector.bf4 |= mask) : (injector.bf5 |= mask)) :\n            (bloomBit < 224 ? (injector.bf6 |= mask) : (injector.bf7 |= mask));\n    }\n}\nfunction getOrCreateNodeInjector() {\n    ngDevMode && assertPreviousIsParent();\n    return getOrCreateNodeInjectorForNode(getPreviousOrParentNode());\n}\n/**\n * Creates (or gets an existing) injector for a given element or container.\n *\n * @param node for which an injector should be retrieved / created.\n * @returns Node injector\n */\nfunction getOrCreateNodeInjectorForNode(node) {\n    var nodeInjector = node.nodeInjector;\n    var parentInjector = node.parent && node.parent.nodeInjector;\n    if (nodeInjector != parentInjector) {\n        return nodeInjector;\n    }\n    return node.nodeInjector = {\n        parent: parentInjector,\n        node: node,\n        bf0: 0,\n        bf1: 0,\n        bf2: 0,\n        bf3: 0,\n        bf4: 0,\n        bf5: 0,\n        bf6: 0,\n        bf7: 0,\n        cbf0: parentInjector == null ? 0 : parentInjector.cbf0 | parentInjector.bf0,\n        cbf1: parentInjector == null ? 0 : parentInjector.cbf1 | parentInjector.bf1,\n        cbf2: parentInjector == null ? 0 : parentInjector.cbf2 | parentInjector.bf2,\n        cbf3: parentInjector == null ? 0 : parentInjector.cbf3 | parentInjector.bf3,\n        cbf4: parentInjector == null ? 0 : parentInjector.cbf4 | parentInjector.bf4,\n        cbf5: parentInjector == null ? 0 : parentInjector.cbf5 | parentInjector.bf5,\n        cbf6: parentInjector == null ? 0 : parentInjector.cbf6 | parentInjector.bf6,\n        cbf7: parentInjector == null ? 0 : parentInjector.cbf7 | parentInjector.bf7,\n        templateRef: null,\n        viewContainerRef: null,\n        elementRef: null,\n        changeDetectorRef: null\n    };\n}\n/**\n * Makes a directive public to the DI system by adding it to an injector's bloom filter.\n *\n * @param di The node injector in which a directive will be added\n * @param def The definition of the directive to be made public\n */\nfunction diPublicInInjector(di, def) {\n    bloomAdd(di, def.type);\n}\n/**\n * Makes a directive public to the DI system by adding it to an injector's bloom filter.\n *\n * @param def The definition of the directive to be made public\n */\nfunction diPublic(def) {\n    diPublicInInjector(getOrCreateNodeInjector(), def);\n}\nfunction directiveInject(token, flags) {\n    if (flags === void 0) { flags = 0 /* Default */; }\n    return getOrCreateInjectable(getOrCreateNodeInjector(), token, flags);\n}\n/**\n * Creates an ElementRef and stores it on the injector.\n * Or, if the ElementRef already exists, retrieves the existing ElementRef.\n *\n * @returns The ElementRef instance to use\n */\n\n/**\n * Creates a TemplateRef and stores it on the injector. Or, if the TemplateRef already\n * exists, retrieves the existing TemplateRef.\n *\n * @returns The TemplateRef instance to use\n */\nfunction injectTemplateRef() {\n    return getOrCreateTemplateRef(getOrCreateNodeInjector());\n}\n/**\n * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef\n * already exists, retrieves the existing ViewContainerRef.\n *\n * @returns The ViewContainerRef instance to use\n */\nfunction injectViewContainerRef() {\n    return getOrCreateContainerRef(getOrCreateNodeInjector());\n}\n/** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */\nfunction injectChangeDetectorRef() {\n    return getOrCreateChangeDetectorRef(getOrCreateNodeInjector(), null);\n}\n/**\n * Inject static attribute value into directive constructor.\n *\n * This method is used with `factory` functions which are generated as part of\n * `defineDirective` or `defineComponent`. The method retrieves the static value\n * of an attribute. (Dynamic attributes are not supported since they are not resolved\n *  at the time of injection and can change over time.)\n *\n * # Example\n * Given:\n * ```\n * @Component(...)\n * class MyComponent {\n *   constructor(@Attribute('title') title: string) { ... }\n * }\n * ```\n * When instantiated with\n * ```\n * <my-component title=\"Hello\"></my-component>\n * ```\n *\n * Then factory method generated is:\n * ```\n * MyComponent.ngComponentDef = defineComponent({\n *   factory: () => new MyComponent(injectAttribute('title'))\n *   ...\n * })\n * ```\n *\n * @experimental\n */\nfunction injectAttribute(attrName) {\n    ngDevMode && assertPreviousIsParent();\n    var lElement = getPreviousOrParentNode();\n    ngDevMode && assertNodeType(lElement, 3 /* Element */);\n    var tElement = lElement.tNode;\n    ngDevMode && assertNotNull(tElement, 'expecting tNode');\n    var attrs = tElement.attrs;\n    if (attrs) {\n        for (var i = 0; i < attrs.length; i = i + 2) {\n            if (attrs[i] == attrName) {\n                return attrs[i + 1];\n            }\n        }\n    }\n    return undefined;\n}\n/**\n * Creates a ViewRef and stores it on the injector as ChangeDetectorRef (public alias).\n * Or, if it already exists, retrieves the existing instance.\n *\n * @returns The ChangeDetectorRef to use\n */\nfunction getOrCreateChangeDetectorRef(di, context) {\n    if (di.changeDetectorRef)\n        return di.changeDetectorRef;\n    var currentNode = di.node;\n    if (isComponent(currentNode.tNode)) {\n        return di.changeDetectorRef = createViewRef(currentNode.data, context);\n    }\n    else if (currentNode.type === 3 /* Element */) {\n        return di.changeDetectorRef = getOrCreateHostChangeDetector(currentNode.view.node);\n    }\n    return null;\n}\n/** Gets or creates ChangeDetectorRef for the closest host component */\nfunction getOrCreateHostChangeDetector(currentNode) {\n    var hostNode = getClosestComponentAncestor(currentNode);\n    var hostInjector = hostNode.nodeInjector;\n    var existingRef = hostInjector && hostInjector.changeDetectorRef;\n    return existingRef ?\n        existingRef :\n        createViewRef(hostNode.data, hostNode.view\n            .directives[hostNode.tNode.flags >> 13 /* DirectiveStartingIndexShift */]);\n}\n/**\n * If the node is an embedded view, traverses up the view tree to return the closest\n * ancestor view that is attached to a component. If it's already a component node,\n * returns itself.\n */\nfunction getClosestComponentAncestor(node) {\n    while (node.type === 2 /* View */) {\n        node = node.view.node;\n    }\n    return node;\n}\n/**\n * Searches for an instance of the given directive type up the injector tree and returns\n * that instance if found.\n *\n * Specifically, it gets the bloom filter bit associated with the directive (see bloomHashBit),\n * checks that bit against the bloom filter structure to identify an injector that might have\n * the directive (see bloomFindPossibleInjector), then searches the directives on that injector\n * for a match.\n *\n * If not found, it will propagate up to the next parent injector until the token\n * is found or the top is reached.\n *\n * @param di Node injector where the search should start\n * @param token The directive type to search for\n * @param flags Injection flags (e.g. CheckParent)\n * @returns The instance found\n */\nfunction getOrCreateInjectable(di, token, flags) {\n    var bloomHash = bloomHashBit(token);\n    // If the token has a bloom hash, then it is a directive that is public to the injection system\n    // (diPublic). If there is no hash, fall back to the module injector.\n    if (bloomHash === null) {\n        var moduleInjector = getPreviousOrParentNode().view.injector;\n        var formerInjector = setCurrentInjector(moduleInjector);\n        try {\n            return inject(token, flags);\n        }\n        finally {\n            setCurrentInjector(formerInjector);\n        }\n    }\n    else {\n        var injector = di;\n        while (injector) {\n            // Get the closest potential matching injector (upwards in the injector tree) that\n            // *potentially* has the token.\n            injector = bloomFindPossibleInjector(injector, bloomHash);\n            // If no injector is found, we *know* that there is no ancestor injector that contains the\n            // token, so we abort.\n            if (!injector) {\n                break;\n            }\n            // At this point, we have an injector which *may* contain the token, so we step through the\n            // directives associated with the injector's corresponding node to get the directive instance.\n            var node = injector.node;\n            var flags_1 = node.tNode.flags;\n            var count = flags_1 & 4095;\n            if (count !== 0) {\n                var start = flags_1 >> 13;\n                var end = start + count;\n                var defs = node.view.tView.directives;\n                for (var i = start; i < end; i++) {\n                    // Get the definition for the directive at this index and, if it is injectable (diPublic),\n                    // and matches the given token, return the directive instance.\n                    var directiveDef = defs[i];\n                    if (directiveDef.type === token && directiveDef.diPublic) {\n                        return getDirectiveInstance(node.view.directives[i]);\n                    }\n                }\n            }\n            // If we *didn't* find the directive for the token and we are searching the current node's\n            // injector, it's possible the directive is on this node and hasn't been created yet.\n            var instance = void 0;\n            if (injector === di && (instance = searchMatchesQueuedForCreation(node, token))) {\n                return instance;\n            }\n            // The def wasn't found anywhere on this node, so it might be a false positive.\n            // Traverse up the tree and continue searching.\n            injector = injector.parent;\n        }\n    }\n    // No directive was found for the given token.\n    // TODO: implement optional, check-self, and check-parent.\n    throw new Error('Implement');\n}\nfunction searchMatchesQueuedForCreation(node, token) {\n    var matches = node.view.tView.currentMatches;\n    if (matches) {\n        for (var i = 0; i < matches.length; i += 2) {\n            var def = matches[i];\n            if (def.type === token) {\n                return resolveDirective(def, i + 1, matches, node.view.tView);\n            }\n        }\n    }\n    return null;\n}\n/**\n * Given a directive type, this function returns the bit in an injector's bloom filter\n * that should be used to determine whether or not the directive is present.\n *\n * When the directive was added to the bloom filter, it was given a unique ID that can be\n * retrieved on the class. Since there are only BLOOM_SIZE slots per bloom filter, the directive's\n * ID must be modulo-ed by BLOOM_SIZE to get the correct bloom bit (directives share slots after\n * BLOOM_SIZE is reached).\n *\n * @param type The directive type\n * @returns The bloom bit to check for the directive\n */\nfunction bloomHashBit(type) {\n    var id = type[NG_ELEMENT_ID];\n    return typeof id === 'number' ? id % BLOOM_SIZE : null;\n}\n/**\n * Finds the closest injector that might have a certain directive.\n *\n * Each directive corresponds to a bit in an injector's bloom filter. Given the bloom bit to\n * check and a starting injector, this function traverses up injectors until it finds an\n * injector that contains a 1 for that bit in its bloom filter. A 1 indicates that the\n * injector may have that directive. It only *may* have the directive because directives begin\n * to share bloom filter bits after the BLOOM_SIZE is reached, and it could correspond to a\n * different directive sharing the bit.\n *\n * Note: We can skip checking further injectors up the tree if an injector's cbf structure\n * has a 0 for that bloom bit. Since cbf contains the merged value of all the parent\n * injectors, a 0 in the bloom bit indicates that the parents definitely do not contain\n * the directive and do not need to be checked.\n *\n * @param injector The starting node injector to check\n * @param  bloomBit The bit to check in each injector's bloom filter\n * @returns An injector that might have the directive\n */\nfunction bloomFindPossibleInjector(startInjector, bloomBit) {\n    // Create a mask that targets the specific bit associated with the directive we're looking for.\n    // JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding\n    // to bit positions 0 - 31 in a 32 bit integer.\n    var mask = 1 << bloomBit;\n    // Traverse up the injector tree until we find a potential match or until we know there *isn't* a\n    // match.\n    var injector = startInjector;\n    while (injector) {\n        // Our bloom filter size is 256 bits, which is eight 32-bit bloom filter buckets:\n        // bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc.\n        // Get the bloom filter value from the appropriate bucket based on the directive's bloomBit.\n        var value = void 0;\n        if (bloomBit < 128) {\n            value = bloomBit < 64 ? (bloomBit < 32 ? injector.bf0 : injector.bf1) :\n                (bloomBit < 96 ? injector.bf2 : injector.bf3);\n        }\n        else {\n            value = bloomBit < 192 ? (bloomBit < 160 ? injector.bf4 : injector.bf5) :\n                (bloomBit < 224 ? injector.bf6 : injector.bf7);\n        }\n        // If the bloom filter value has the bit corresponding to the directive's bloomBit flipped on,\n        // this injector is a potential match.\n        if ((value & mask) === mask) {\n            return injector;\n        }\n        // If the current injector does not have the directive, check the bloom filters for the ancestor\n        // injectors (cbf0 - cbf7). These filters capture *all* ancestor injectors.\n        if (bloomBit < 128) {\n            value = bloomBit < 64 ? (bloomBit < 32 ? injector.cbf0 : injector.cbf1) :\n                (bloomBit < 96 ? injector.cbf2 : injector.cbf3);\n        }\n        else {\n            value = bloomBit < 192 ? (bloomBit < 160 ? injector.cbf4 : injector.cbf5) :\n                (bloomBit < 224 ? injector.cbf6 : injector.cbf7);\n        }\n        // If the ancestor bloom filter value has the bit corresponding to the directive, traverse up to\n        // find the specific injector. If the ancestor bloom filter does not have the bit, we can abort.\n        injector = (value & mask) ? injector.parent : null;\n    }\n    return null;\n}\nvar ReadFromInjectorFn = /** @class */ (function () {\n    function ReadFromInjectorFn(read) {\n        this.read = read;\n    }\n    return ReadFromInjectorFn;\n}());\n/**\n * Creates an ElementRef for a given node injector and stores it on the injector.\n * Or, if the ElementRef already exists, retrieves the existing ElementRef.\n *\n * @param di The node injector where we should store a created ElementRef\n * @returns The ElementRef instance to use\n */\nfunction getOrCreateElementRef(di) {\n    return di.elementRef || (di.elementRef = new ElementRef$1(di.node.type === 0 /* Container */ ? null : di.node.native));\n}\n\n\n\n\n/** A ref to a node's native element. */\nvar ElementRef$1 = /** @class */ (function () {\n    function ElementRef(nativeElement) {\n        this.nativeElement = nativeElement;\n    }\n    return ElementRef;\n}());\n/**\n * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef\n * already exists, retrieves the existing ViewContainerRef.\n *\n * @returns The ViewContainerRef instance to use\n */\nfunction getOrCreateContainerRef(di) {\n    if (!di.viewContainerRef) {\n        var vcRefHost = di.node;\n        ngDevMode && assertNodeOfPossibleTypes(vcRefHost, 0 /* Container */, 3 /* Element */);\n        var lContainer = createLContainer(vcRefHost.parent, vcRefHost.view);\n        var lContainerNode = createLNodeObject(0 /* Container */, vcRefHost.view, vcRefHost.parent, undefined, lContainer, null);\n        vcRefHost.dynamicLContainerNode = lContainerNode;\n        addToViewTree(vcRefHost.view, lContainer);\n        di.viewContainerRef = new ViewContainerRef$1(lContainerNode);\n    }\n    return di.viewContainerRef;\n}\n/**\n * A ref to a container that enables adding and removing views from that container\n * imperatively.\n */\nvar ViewContainerRef$1 = /** @class */ (function () {\n    function ViewContainerRef(_lContainerNode) {\n        this._lContainerNode = _lContainerNode;\n        this._viewRefs = [];\n    }\n    ViewContainerRef.prototype.clear = function () {\n        var lContainer = this._lContainerNode.data;\n        while (lContainer.views.length) {\n            this.remove(0);\n        }\n    };\n    ViewContainerRef.prototype.get = function (index) { return this._viewRefs[index] || null; };\n    Object.defineProperty(ViewContainerRef.prototype, \"length\", {\n        get: function () {\n            var lContainer = this._lContainerNode.data;\n            return lContainer.views.length;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ViewContainerRef.prototype.createEmbeddedView = function (templateRef, context, index) {\n        var viewRef = templateRef.createEmbeddedView(context || {});\n        this.insert(viewRef, index);\n        return viewRef;\n    };\n    ViewContainerRef.prototype.createComponent = function (componentFactory, index, injector, projectableNodes, ngModule) {\n        throw notImplemented();\n    };\n    ViewContainerRef.prototype.insert = function (viewRef, index) {\n        var lViewNode = viewRef._lViewNode;\n        var adjustedIdx = this._adjustIndex(index);\n        insertView(this._lContainerNode, lViewNode, adjustedIdx);\n        // invalidate cache of next sibling RNode (we do similar operation in the containerRefreshEnd\n        // instruction)\n        this._lContainerNode.native = undefined;\n        this._viewRefs.splice(adjustedIdx, 0, viewRef);\n        lViewNode.parent = this._lContainerNode;\n        // If the view is dynamic (has a template), it needs to be counted both at the container\n        // level and at the node above the container.\n        if (lViewNode.data.template !== null) {\n            // Increment the container view count.\n            this._lContainerNode.data.dynamicViewCount++;\n            // Look for the parent node and increment its dynamic view count.\n            if (this._lContainerNode.parent !== null && this._lContainerNode.parent.data !== null) {\n                ngDevMode && assertNodeOfPossibleTypes(this._lContainerNode.parent, 2 /* View */, 3 /* Element */);\n                this._lContainerNode.parent.data.dynamicViewCount++;\n            }\n        }\n        return viewRef;\n    };\n    ViewContainerRef.prototype.move = function (viewRef, newIndex) {\n        var index = this.indexOf(viewRef);\n        this.detach(index);\n        this.insert(viewRef, this._adjustIndex(newIndex));\n        return viewRef;\n    };\n    ViewContainerRef.prototype.indexOf = function (viewRef) { return this._viewRefs.indexOf(viewRef); };\n    ViewContainerRef.prototype.remove = function (index) {\n        this.detach(index);\n        // TODO(ml): proper destroy of the ViewRef, i.e. recursively destroy the LviewNode and its\n        // children, delete DOM nodes and QueryList, trigger hooks (onDestroy), destroy the renderer,\n        // detach projected nodes\n    };\n    ViewContainerRef.prototype.detach = function (index) {\n        var adjustedIdx = this._adjustIndex(index, -1);\n        removeView(this._lContainerNode, adjustedIdx);\n        return this._viewRefs.splice(adjustedIdx, 1)[0] || null;\n    };\n    ViewContainerRef.prototype._adjustIndex = function (index, shift) {\n        if (shift === void 0) { shift = 0; }\n        if (index == null) {\n            return this._lContainerNode.data.views.length + shift;\n        }\n        if (ngDevMode) {\n            assertGreaterThan(index, -1, 'index must be positive');\n            // +1 because it's legal to insert at the end.\n            assertLessThan(index, this._lContainerNode.data.views.length + 1 + shift, 'index');\n        }\n        return index;\n    };\n    return ViewContainerRef;\n}());\n/**\n * Creates a TemplateRef and stores it on the injector. Or, if the TemplateRef already\n * exists, retrieves the existing TemplateRef.\n *\n * @param di The node injector where we should store a created TemplateRef\n * @returns The TemplateRef instance to use\n */\nfunction getOrCreateTemplateRef(di) {\n    ngDevMode && assertNodeType(di.node, 0 /* Container */);\n    var data = di.node.data;\n    var tView = di.node.view.tView;\n    return di.templateRef || (di.templateRef = new TemplateRef$1(getOrCreateElementRef(di), data.template, getRenderer(), tView.directiveRegistry, tView.pipeRegistry));\n}\nvar TemplateRef$1 = /** @class */ (function () {\n    function TemplateRef(elementRef, template, _renderer, _directives, _pipes) {\n        this._renderer = _renderer;\n        this._directives = _directives;\n        this._pipes = _pipes;\n        this.elementRef = elementRef;\n        this._template = template;\n    }\n    TemplateRef.prototype.createEmbeddedView = function (context) {\n        var viewNode = renderEmbeddedTemplate(null, this._template, context, this._renderer, this._directives, this._pipes);\n        return addDestroyable(new EmbeddedViewRef$1(viewNode, this._template, context));\n    };\n    return TemplateRef;\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 * Create a component definition object.\n *\n *\n * # Example\n * ```\n * class MyDirective {\n *   // Generated by Angular Template Compiler\n *   // [Symbol] syntax will not be supported by TypeScript until v2.7\n *   static ngComponentDef = defineComponent({\n *     ...\n *   });\n * }\n * ```\n */\nfunction defineComponent(componentDefinition) {\n    var type = componentDefinition.type;\n    var pipeTypes = componentDefinition.pipes;\n    var directiveTypes = componentDefinition.directives;\n    var def = {\n        type: type,\n        diPublic: null,\n        factory: componentDefinition.factory,\n        template: componentDefinition.template || null,\n        hostBindings: componentDefinition.hostBindings || null,\n        attributes: componentDefinition.attributes || null,\n        inputs: invertObject(componentDefinition.inputs),\n        outputs: invertObject(componentDefinition.outputs),\n        rendererType: resolveRendererType2(componentDefinition.rendererType) || null,\n        exportAs: componentDefinition.exportAs,\n        onInit: type.prototype.ngOnInit || null,\n        doCheck: type.prototype.ngDoCheck || null,\n        afterContentInit: type.prototype.ngAfterContentInit || null,\n        afterContentChecked: type.prototype.ngAfterContentChecked || null,\n        afterViewInit: type.prototype.ngAfterViewInit || null,\n        afterViewChecked: type.prototype.ngAfterViewChecked || null,\n        onDestroy: type.prototype.ngOnDestroy || null,\n        onPush: componentDefinition.changeDetection === exports.ChangeDetectionStrategy.OnPush,\n        directiveDefs: directiveTypes ?\n            function () { return (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)\n                .map(extractDirectiveDef); } :\n            null,\n        pipeDefs: pipeTypes ?\n            function () { return (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef); } :\n            null,\n        selectors: componentDefinition.selectors\n    };\n    var feature = componentDefinition.features;\n    feature && feature.forEach(function (fn) { return fn(def); });\n    return def;\n}\nfunction extractDirectiveDef(type) {\n    var def = type.ngComponentDef || type.ngDirectiveDef;\n    if (ngDevMode && !def) {\n        throw new Error(\"'\" + type.name + \"' is neither 'ComponentType' or 'DirectiveType'.\");\n    }\n    return def;\n}\nfunction extractPipeDef(type) {\n    var def = type.ngPipeDef;\n    if (ngDevMode && !def) {\n        throw new Error(\"'\" + type.name + \"' is not a 'PipeType'.\");\n    }\n    return def;\n}\nvar PRIVATE_PREFIX = '__ngOnChanges_';\n/**\n * Creates an NgOnChangesFeature function for a component's features list.\n *\n * It accepts an optional map of minified input property names to original property names,\n * if any input properties have a public alias.\n *\n * The NgOnChangesFeature function that is returned decorates a component with support for\n * the ngOnChanges lifecycle hook, so it should be included in any component that implements\n * that hook.\n *\n * Example usage:\n *\n * ```\n * static ngComponentDef = defineComponent({\n *   ...\n *   inputs: {name: 'publicName'},\n *   features: [NgOnChangesFeature({name: 'name'})]\n * });\n * ```\n *\n * @param inputPropertyNames Map of input property names, if they are aliased\n * @returns DirectiveDefFeature\n */\nfunction NgOnChangesFeature(inputPropertyNames) {\n    return function (definition) {\n        var inputs = definition.inputs;\n        var proto = definition.type.prototype;\n        // Place where we will store SimpleChanges if there is a change\n        Object.defineProperty(proto, PRIVATE_PREFIX, { value: undefined, writable: true });\n        var _loop_1 = function (pubKey) {\n            var minKey = inputs[pubKey];\n            var propertyName = inputPropertyNames && inputPropertyNames[minKey] || pubKey;\n            var privateMinKey = PRIVATE_PREFIX + minKey;\n            // Create a place where the actual value will be stored and make it non-enumerable\n            Object.defineProperty(proto, privateMinKey, { value: undefined, writable: true });\n            var existingDesc = Object.getOwnPropertyDescriptor(proto, minKey);\n            // create a getter and setter for property\n            Object.defineProperty(proto, minKey, {\n                get: function () {\n                    return (existingDesc && existingDesc.get) ? existingDesc.get.call(this) :\n                        this[privateMinKey];\n                },\n                set: function (value) {\n                    var simpleChanges = this[PRIVATE_PREFIX];\n                    var isFirstChange = simpleChanges === undefined;\n                    if (simpleChanges == null) {\n                        simpleChanges = this[PRIVATE_PREFIX] = {};\n                    }\n                    simpleChanges[propertyName] = new SimpleChange(this[privateMinKey], value, isFirstChange);\n                    (existingDesc && existingDesc.set) ? existingDesc.set.call(this, value) :\n                        this[privateMinKey] = value;\n                }\n            });\n        };\n        for (var pubKey in inputs) {\n            _loop_1(pubKey);\n        }\n        // If an onInit hook is defined, it will need to wrap the ngOnChanges call\n        // so the call order is changes-init-check in creation mode. In subsequent\n        // change detection runs, only the check wrapper will be called.\n        if (definition.onInit != null) {\n            definition.onInit = onChangesWrapper(definition.onInit);\n        }\n        definition.doCheck = onChangesWrapper(definition.doCheck);\n    };\n    function onChangesWrapper(delegateHook) {\n        return function () {\n            var simpleChanges = this[PRIVATE_PREFIX];\n            if (simpleChanges != null) {\n                this.ngOnChanges(simpleChanges);\n                this[PRIVATE_PREFIX] = null;\n            }\n            delegateHook && delegateHook.apply(this);\n        };\n    }\n}\nfunction PublicFeature(definition) {\n    definition.diPublic = diPublic;\n}\nvar EMPTY$1 = {};\n/** Swaps the keys and values of an object. */\nfunction invertObject(obj) {\n    if (obj == null)\n        return EMPTY$1;\n    var newObj = {};\n    for (var minifiedKey in obj) {\n        newObj[obj[minifiedKey]] = minifiedKey;\n    }\n    return newObj;\n}\n/**\n * Create a directive definition object.\n *\n * # Example\n * ```\n * class MyDirective {\n *   // Generated by Angular Template Compiler\n *   // [Symbol] syntax will not be supported by TypeScript until v2.7\n *   static ngDirectiveDef = defineDirective({\n *     ...\n *   });\n * }\n * ```\n */\nvar defineDirective = defineComponent;\n/**\n * Create a pipe definition object.\n *\n * # Example\n * ```\n * class MyPipe implements PipeTransform {\n *   // Generated by Angular Template Compiler\n *   static ngPipeDef = definePipe({\n *     ...\n *   });\n * }\n * ```\n * @param pipeDef Pipe definition generated by the compiler\n */\nfunction definePipe(pipeDef) {\n    return {\n        name: pipeDef.name,\n        n: pipeDef.factory,\n        pure: pipeDef.pure !== false,\n        onDestroy: pipeDef.type.prototype.ngOnDestroy || null\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 * If the value hasn't been saved, calls the pure function to store and return the\n * value. If it has been saved, returns the saved value.\n *\n * @param pureFn Function that returns a value\n * @returns value\n */\nfunction pureFunction0(pureFn, thisArg) {\n    return getCreationMode() ? checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg) : pureFn()) :\n        consumeBinding();\n}\n/**\n * If the value of the provided exp has changed, calls the pure function to return\n * an updated value. Or if the value has not changed, returns cached value.\n *\n * @param pureFn Function that returns an updated value\n * @param exp Updated expression value\n * @returns Updated value\n */\nfunction pureFunction1(pureFn, exp, thisArg) {\n    return bindingUpdated(exp) ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp) : pureFn(exp)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @returns Updated value\n */\nfunction pureFunction2(pureFn, exp1, exp2, thisArg) {\n    return bindingUpdated2(exp1, exp2) ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2) : pureFn(exp1, exp2)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @returns Updated value\n */\nfunction pureFunction3(pureFn, exp1, exp2, exp3, thisArg) {\n    var different = bindingUpdated2(exp1, exp2);\n    return bindingUpdated(exp3) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3) : pureFn(exp1, exp2, exp3)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @returns Updated value\n */\nfunction pureFunction4(pureFn, exp1, exp2, exp3, exp4, thisArg) {\n    return bindingUpdated4(exp1, exp2, exp3, exp4) ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4) : pureFn(exp1, exp2, exp3, exp4)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @returns Updated value\n */\nfunction pureFunction5(pureFn, exp1, exp2, exp3, exp4, exp5, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    return bindingUpdated(exp5) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5) :\n            pureFn(exp1, exp2, exp3, exp4, exp5)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @param exp6\n * @returns Updated value\n */\nfunction pureFunction6(pureFn, exp1, exp2, exp3, exp4, exp5, exp6, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    return bindingUpdated2(exp5, exp6) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6) :\n            pureFn(exp1, exp2, exp3, exp4, exp5, exp6)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @param exp6\n * @param exp7\n * @returns Updated value\n */\nfunction pureFunction7(pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    different = bindingUpdated2(exp5, exp6) || different;\n    return bindingUpdated(exp7) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6, exp7) :\n            pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7)) :\n        consumeBinding();\n}\n/**\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn\n * @param exp1\n * @param exp2\n * @param exp3\n * @param exp4\n * @param exp5\n * @param exp6\n * @param exp7\n * @param exp8\n * @returns Updated value\n */\nfunction pureFunction8(pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8, thisArg) {\n    var different = bindingUpdated4(exp1, exp2, exp3, exp4);\n    return bindingUpdated4(exp5, exp6, exp7, exp8) || different ?\n        checkAndUpdateBinding$1(thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8) :\n            pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8)) :\n        consumeBinding();\n}\n/**\n * pureFunction instruction that can support any number of bindings.\n *\n * If the value of any provided exp has changed, calls the pure function to return\n * an updated value. Or if no values have changed, returns cached value.\n *\n * @param pureFn A pure function that takes binding values and builds an object or array\n * containing those values.\n * @param exp An array of binding values\n * @returns Updated value\n */\nfunction pureFunctionV(pureFn, exps, thisArg) {\n    var different = false;\n    for (var i = 0; i < exps.length; i++) {\n        bindingUpdated(exps[i]) && (different = true);\n    }\n    return different ? checkAndUpdateBinding$1(pureFn.apply(thisArg, exps)) : consumeBinding();\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 * Create a pipe.\n *\n * @param index Pipe index where the pipe will be stored.\n * @param pipeName The name of the pipe\n * @returns T the instance of the pipe.\n */\nfunction pipe(index, pipeName) {\n    var tView = getTView();\n    var pipeDef;\n    if (tView.firstTemplatePass) {\n        pipeDef = getPipeDef(pipeName, tView.pipeRegistry);\n        tView.data[index] = pipeDef;\n        if (pipeDef.onDestroy) {\n            (tView.pipeDestroyHooks || (tView.pipeDestroyHooks = [])).push(index, pipeDef.onDestroy);\n        }\n    }\n    else {\n        pipeDef = tView.data[index];\n    }\n    var pipeInstance = pipeDef.n();\n    store(index, pipeInstance);\n    return pipeInstance;\n}\n/**\n * Searches the pipe registry for a pipe with the given name. If one is found,\n * returns the pipe. Otherwise, an error is thrown because the pipe cannot be resolved.\n *\n * @param name Name of pipe to resolve\n * @param registry Full list of available pipes\n * @returns Matching PipeDef\n */\nfunction getPipeDef(name, registry) {\n    if (registry) {\n        for (var i = 0; i < registry.length; i++) {\n            var pipeDef = registry[i];\n            if (name === pipeDef.name) {\n                return pipeDef;\n            }\n        }\n    }\n    throw new Error(\"Pipe with name '\" + name + \"' not found!\");\n}\n/**\n * Invokes a pipe with 1 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind1(index, v1) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction1(pipeInstance.transform, v1, pipeInstance) :\n        pipeInstance.transform(v1);\n}\n/**\n * Invokes a pipe with 2 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind2(index, v1, v2) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction2(pipeInstance.transform, v1, v2, pipeInstance) :\n        pipeInstance.transform(v1, v2);\n}\n/**\n * Invokes a pipe with 3 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 4rd argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind3(index, v1, v2, v3) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction3(pipeInstance.transform.bind(pipeInstance), v1, v2, v3) :\n        pipeInstance.transform(v1, v2, v3);\n}\n/**\n * Invokes a pipe with 4 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 3rd argument to {@link PipeTransform#transform}.\n * @param v4 4th argument to {@link PipeTransform#transform}.\n */\nfunction pipeBind4(index, v1, v2, v3, v4) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunction4(pipeInstance.transform, v1, v2, v3, v4, pipeInstance) :\n        pipeInstance.transform(v1, v2, v3, v4);\n}\n/**\n * Invokes a pipe with variable number of arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param values Array of arguments to pass to {@link PipeTransform#transform} method.\n */\nfunction pipeBindV(index, values) {\n    var pipeInstance = load(index);\n    return isPure(index) ? pureFunctionV(pipeInstance.transform, values, pipeInstance) :\n        pipeInstance.transform.apply(pipeInstance, values);\n}\nfunction isPure(index) {\n    return getTView().data[index].pure;\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\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// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar LQueries_ = /** @class */ (function () {\n    function LQueries_(deep) {\n        this.shallow = null;\n        this.deep = null;\n        this.deep = deep == null ? null : deep;\n    }\n    LQueries_.prototype.track = function (queryList, predicate, descend, read) {\n        // TODO(misko): This is not right. In case of inherited state, a calling track will incorrectly\n        // mutate parent.\n        if (descend) {\n            this.deep = createQuery$1(this.deep, queryList, predicate, read != null ? read : null);\n        }\n        else {\n            this.shallow = createQuery$1(this.shallow, queryList, predicate, read != null ? read : null);\n        }\n    };\n    LQueries_.prototype.child = function () {\n        if (this.deep === null) {\n            // if we don't have any deep queries then no need to track anything more.\n            return null;\n        }\n        if (this.shallow === null) {\n            // DeepQuery: We can reuse the current state if the child state would be same as current\n            // state.\n            return this;\n        }\n        else {\n            // We need to create new state\n            return new LQueries_(this.deep);\n        }\n    };\n    LQueries_.prototype.container = function () {\n        var result = null;\n        var query = this.deep;\n        while (query) {\n            var containerValues = []; // prepare room for views\n            query.values.push(containerValues);\n            var clonedQuery = { next: null, list: query.list, predicate: query.predicate, values: containerValues };\n            clonedQuery.next = result;\n            result = clonedQuery;\n            query = query.next;\n        }\n        return result ? new LQueries_(result) : null;\n    };\n    LQueries_.prototype.enterView = function (index) {\n        var result = null;\n        var query = this.deep;\n        while (query) {\n            var viewValues = []; // prepare room for view nodes\n            query.values.splice(index, 0, viewValues);\n            var clonedQuery = { next: null, list: query.list, predicate: query.predicate, values: viewValues };\n            clonedQuery.next = result;\n            result = clonedQuery;\n            query = query.next;\n        }\n        return result ? new LQueries_(result) : null;\n    };\n    LQueries_.prototype.addNode = function (node) {\n        add(this.shallow, node);\n        add(this.deep, node);\n    };\n    LQueries_.prototype.removeView = function (index) {\n        var query = this.deep;\n        while (query) {\n            var removed = query.values.splice(index, 1);\n            // mark a query as dirty only when removed view had matching modes\n            ngDevMode && assertEqual(removed.length, 1, 'removed.length');\n            if (removed[0].length) {\n                query.list.setDirty();\n            }\n            query = query.next;\n        }\n    };\n    return LQueries_;\n}());\n/**\n * Iterates over local names for a given node and returns directive index\n * (or -1 if a local name points to an element).\n *\n * @param tNode static data of a node to check\n * @param selector selector to match\n * @returns directive index, -1 or null if a selector didn't match any of the local names\n */\nfunction getIdxOfMatchingSelector(tNode, selector) {\n    var localNames = tNode.localNames;\n    if (localNames) {\n        for (var i = 0; i < localNames.length; i += 2) {\n            if (localNames[i] === selector) {\n                return localNames[i + 1];\n            }\n        }\n    }\n    return null;\n}\n/**\n * Iterates over all the directives for a node and returns index of a directive for a given type.\n *\n * @param node Node on which directives are present.\n * @param type Type of a directive to look for.\n * @returns Index of a found directive or null when none found.\n */\nfunction getIdxOfMatchingDirective(node, type) {\n    var defs = node.view.tView.directives;\n    var flags = node.tNode.flags;\n    var count = flags & 4095;\n    var start = flags >> 13;\n    var end = start + count;\n    for (var i = start; i < end; i++) {\n        var def = defs[i];\n        if (def.type === type && def.diPublic) {\n            return i;\n        }\n    }\n    return null;\n}\nfunction readFromNodeInjector(nodeInjector, node, read, directiveIdx) {\n    if (read instanceof ReadFromInjectorFn) {\n        return read.read(nodeInjector, node, directiveIdx);\n    }\n    else {\n        var matchingIdx = getIdxOfMatchingDirective(node, read);\n        if (matchingIdx !== null) {\n            return node.view.directives[matchingIdx];\n        }\n    }\n    return null;\n}\nfunction add(query, node) {\n    var nodeInjector = getOrCreateNodeInjectorForNode(node);\n    while (query) {\n        var predicate = query.predicate;\n        var type = predicate.type;\n        if (type) {\n            var directiveIdx = getIdxOfMatchingDirective(node, type);\n            if (directiveIdx !== null) {\n                // a node is matching a predicate - determine what to read\n                // if read token and / or strategy is not specified, use type as read token\n                var result = readFromNodeInjector(nodeInjector, node, predicate.read || type, directiveIdx);\n                if (result !== null) {\n                    addMatch(query, result);\n                }\n            }\n        }\n        else {\n            var selector = predicate.selector;\n            for (var i = 0; i < selector.length; i++) {\n                ngDevMode && assertNotNull(node.tNode, 'node.tNode');\n                var directiveIdx = getIdxOfMatchingSelector(node.tNode, selector[i]);\n                if (directiveIdx !== null) {\n                    // a node is matching a predicate - determine what to read\n                    // note that queries using name selector must specify read strategy\n                    ngDevMode && assertNotNull(predicate.read, 'the node should have a predicate');\n                    var result = readFromNodeInjector(nodeInjector, node, predicate.read, directiveIdx);\n                    if (result !== null) {\n                        addMatch(query, result);\n                    }\n                }\n            }\n        }\n        query = query.next;\n    }\n}\nfunction addMatch(query, matchingValue) {\n    query.values.push(matchingValue);\n    query.list.setDirty();\n}\nfunction createPredicate(predicate, read) {\n    var isArray = Array.isArray(predicate);\n    return {\n        type: isArray ? null : predicate,\n        selector: isArray ? predicate : null,\n        read: read\n    };\n}\nfunction createQuery$1(previous, queryList, predicate, read) {\n    return {\n        next: previous,\n        list: queryList,\n        predicate: createPredicate(predicate, read),\n        values: queryList._valuesTree\n    };\n}\nvar QueryList_ = /** @class */ (function () {\n    function QueryList_() {\n        this.dirty = true;\n        this.changes = new EventEmitter();\n        this._values = [];\n        /** @internal */\n        this._valuesTree = [];\n    }\n    Object.defineProperty(QueryList_.prototype, \"length\", {\n        get: function () { return this._values.length; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QueryList_.prototype, \"first\", {\n        get: function () {\n            var values = this._values;\n            return values.length ? values[0] : null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QueryList_.prototype, \"last\", {\n        get: function () {\n            var values = this._values;\n            return values.length ? values[values.length - 1] : null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * See\n     * [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)\n     */\n    QueryList_.prototype.map = function (fn) { return this._values.map(fn); };\n    /**\n     * See\n     * [Array.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)\n     */\n    QueryList_.prototype.filter = function (fn) {\n        return this._values.filter(fn);\n    };\n    /**\n     * See\n     * [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)\n     */\n    QueryList_.prototype.find = function (fn) {\n        return this._values.find(fn);\n    };\n    /**\n     * See\n     * [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)\n     */\n    QueryList_.prototype.reduce = function (fn, init) {\n        return this._values.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     */\n    QueryList_.prototype.forEach = function (fn) { this._values.forEach(fn); };\n    /**\n     * See\n     * [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)\n     */\n    QueryList_.prototype.some = function (fn) {\n        return this._values.some(fn);\n    };\n    QueryList_.prototype.toArray = function () { return this._values.slice(0); };\n    QueryList_.prototype[getSymbolIterator()] = function () { return this._values[getSymbolIterator()](); };\n    QueryList_.prototype.toString = function () { return this._values.toString(); };\n    QueryList_.prototype.reset = function (res) {\n        this._values = flatten$1(res);\n        this.dirty = false;\n    };\n    QueryList_.prototype.notifyOnChanges = function () { this.changes.emit(this); };\n    QueryList_.prototype.setDirty = function () { this.dirty = true; };\n    QueryList_.prototype.destroy = function () {\n        this.changes.complete();\n        this.changes.unsubscribe();\n    };\n    return QueryList_;\n}());\nvar QueryList$1 = QueryList_;\n/**\n * Creates and returns a QueryList.\n *\n * @param memoryIndex The index in memory where the QueryList should be saved. If null,\n * this is is a content query and the QueryList will be saved later through directiveCreate.\n * @param predicate The type for which the query will search\n * @param descend Whether or not to descend into children\n * @param read What to save in the query\n * @returns QueryList<T>\n */\nfunction query(memoryIndex, predicate, descend, read) {\n    ngDevMode && assertPreviousIsParent();\n    var queryList = new QueryList$1();\n    var queries = getCurrentQueries(LQueries_);\n    queries.track(queryList, predicate, descend, read);\n    if (memoryIndex != null) {\n        store(memoryIndex, queryList);\n    }\n    return queryList;\n}\n/**\n * Refreshes a query by combining matches from all active views and removing matches from deleted\n * views.\n * Returns true if a query got dirty during change detection, false otherwise.\n */\nfunction queryRefresh(queryList) {\n    var queryListImpl = queryList;\n    if (queryList.dirty) {\n        queryList.reset(queryListImpl._valuesTree);\n        queryList.notifyOnChanges();\n        return true;\n    }\n    return false;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar BRAND = '__SANITIZER_TRUSTED_BRAND__';\n/**\n * An `html` sanitizer which converts untrusted `html` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `html` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustHtml}.\n *\n * @param unsafeHtml untrusted `html`, typically from the user.\n * @returns `html` string which is safe to display to user, because all of the dangerous javascript\n * and urls have been removed.\n */\nfunction sanitizeHtml(unsafeHtml) {\n    if (unsafeHtml instanceof String && unsafeHtml[BRAND] === 'Html') {\n        return unsafeHtml.toString();\n    }\n    return _sanitizeHtml(document, stringify$1(unsafeHtml));\n}\n/**\n * A `style` sanitizer which converts untrusted `style` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `style` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustStyle}.\n *\n * @param unsafeStyle untrusted `style`, typically from the user.\n * @returns `style` string which is safe to bind to the `style` properties, because all of the\n * dangerous javascript and urls have been removed.\n */\nfunction sanitizeStyle(unsafeStyle) {\n    if (unsafeStyle instanceof String && unsafeStyle[BRAND] === 'Style') {\n        return unsafeStyle.toString();\n    }\n    return _sanitizeStyle(stringify$1(unsafeStyle));\n}\n/**\n * A `url` sanitizer which converts untrusted `url` **string** into trusted string by removing\n * dangerous\n * content.\n *\n * This method parses the `url` and locates potentially dangerous content (such as javascript) and\n * removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustUrl}.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * all of the dangerous javascript has been removed.\n */\nfunction sanitizeUrl(unsafeUrl) {\n    if (unsafeUrl instanceof String && unsafeUrl[BRAND] === 'Url') {\n        return unsafeUrl.toString();\n    }\n    return _sanitizeUrl(stringify$1(unsafeUrl));\n}\n/**\n * A `url` sanitizer which only lets trusted `url`s through.\n *\n * This passes only `url`s marked trusted by calling {@link bypassSanitizationTrustResourceUrl}.\n *\n * @param unsafeResourceUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * only trusted `url`s have been allowed to pass.\n */\nfunction sanitizeResourceUrl(unsafeResourceUrl) {\n    if (unsafeResourceUrl instanceof String &&\n        unsafeResourceUrl[BRAND] === 'ResourceUrl') {\n        return unsafeResourceUrl.toString();\n    }\n    throw new Error('unsafe value used in a resource URL context (see http://g.co/ng/security#xss)');\n}\n/**\n * A `script` sanitizer which only lets trusted javascript through.\n *\n * This passes only `script`s marked trusted by calling {@link bypassSanitizationTrustScript}.\n *\n * @param unsafeScript untrusted `script`, typically from the user.\n * @returns `url` string which is safe to bind to the `<script>` element such as `<img src>`,\n * because only trusted `scripts`s have been allowed to pass.\n */\n\n/**\n * Mark `html` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link htmlSanitizer} to be trusted implicitly.\n *\n * @param trustedHtml `html` string which needs to be implicitly trusted.\n * @returns a `html` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustHtml(trustedHtml) {\n    return bypassSanitizationTrustString(trustedHtml, 'Html');\n}\n/**\n * Mark `style` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link styleSanitizer} to be trusted implicitly.\n *\n * @param trustedStyle `style` string which needs to be implicitly trusted.\n * @returns a `style` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustStyle(trustedStyle) {\n    return bypassSanitizationTrustString(trustedStyle, 'Style');\n}\n/**\n * Mark `script` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link scriptSanitizer} to be trusted implicitly.\n *\n * @param trustedScript `script` string which needs to be implicitly trusted.\n * @returns a `script` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustScript(trustedScript) {\n    return bypassSanitizationTrustString(trustedScript, 'Script');\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link urlSanitizer} to be trusted implicitly.\n *\n * @param trustedUrl `url` string which needs to be implicitly trusted.\n * @returns a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustUrl(trustedUrl) {\n    return bypassSanitizationTrustString(trustedUrl, 'Url');\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {@link resourceUrlSanitizer} to be trusted implicitly.\n *\n * @param trustedResourceUrl `url` string which needs to be implicitly trusted.\n * @returns a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustResourceUrl(trustedResourceUrl) {\n    return bypassSanitizationTrustString(trustedResourceUrl, 'ResourceUrl');\n}\nfunction bypassSanitizationTrustString(trustedString, mode) {\n    var trusted = new String(trustedString);\n    trusted[BRAND] = mode;\n    return trusted;\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// clang-format off\n\n// clang-format on\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @module\n * @description\n * Entry point from which you should import all public core APIs.\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 * @module\n * @description\n * Entry point for all public APIs of this package.\n */\n\n// This file only reexports content of the `src` folder. Keep it that way.\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// This file is not used to build this module. It is only used during editing\n// by the TypeScript language service and during build for verification. `ngc`\n// replaces this file with production index.ts when it rewrites private symbol\n// names.\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexports.ɵangular_packages_core_core_j = _iterableDiffersFactory;\nexports.ɵangular_packages_core_core_k = _keyValueDiffersFactory;\nexports.ɵangular_packages_core_core_l = _localeFactory;\nexports.ɵangular_packages_core_core_f = _appIdRandomProviderFactory;\nexports.ɵangular_packages_core_core_g = defaultKeyValueDiffers;\nexports.ɵangular_packages_core_core_h = DefaultIterableDifferFactory;\nexports.ɵangular_packages_core_core_i = DefaultKeyValueDifferFactory;\nexports.ɵangular_packages_core_core_c = ReflectiveInjector_;\nexports.ɵangular_packages_core_core_d = ReflectiveDependency;\nexports.ɵangular_packages_core_core_e = resolveReflectiveProviders;\nexports.ɵangular_packages_core_core_m = wtfEnabled;\nexports.ɵangular_packages_core_core_o = createScope;\nexports.ɵangular_packages_core_core_n = detectWTF;\nexports.ɵangular_packages_core_core_r = endTimeRange;\nexports.ɵangular_packages_core_core_p = leave;\nexports.ɵangular_packages_core_core_q = startTimeRange;\nexports.ɵangular_packages_core_core_v = getOrCreateChangeDetectorRef;\nexports.ɵangular_packages_core_core_x = getOrCreateContainerRef;\nexports.ɵangular_packages_core_core_w = getOrCreateInjectable;\nexports.ɵangular_packages_core_core_u = getOrCreateNodeInjector;\nexports.ɵangular_packages_core_core_y = getOrCreateTemplateRef;\nexports.ɵangular_packages_core_core_bb = bindingUpdated;\nexports.ɵangular_packages_core_core_bd = bindingUpdated2;\nexports.ɵangular_packages_core_core_be = bindingUpdated4;\nexports.ɵangular_packages_core_core_bc = checkAndUpdateBinding$1;\nexports.ɵangular_packages_core_core_ba = consumeBinding;\nexports.ɵangular_packages_core_core_z = getCreationMode;\nexports.ɵangular_packages_core_core_a = makeParamDecorator;\nexports.ɵangular_packages_core_core_b = makePropDecorator;\nexports.ɵangular_packages_core_core_s = _def;\nexports.ɵangular_packages_core_core_t = DebugContext;\nexports.createPlatform = createPlatform;\nexports.assertPlatform = assertPlatform;\nexports.destroyPlatform = destroyPlatform;\nexports.getPlatform = getPlatform;\nexports.PlatformRef = PlatformRef;\nexports.ApplicationRef = ApplicationRef;\nexports.enableProdMode = enableProdMode;\nexports.isDevMode = isDevMode;\nexports.createPlatformFactory = createPlatformFactory;\nexports.NgProbeToken = NgProbeToken;\nexports.APP_ID = APP_ID;\nexports.PACKAGE_ROOT_URL = PACKAGE_ROOT_URL;\nexports.PLATFORM_INITIALIZER = PLATFORM_INITIALIZER;\nexports.PLATFORM_ID = PLATFORM_ID;\nexports.APP_BOOTSTRAP_LISTENER = APP_BOOTSTRAP_LISTENER;\nexports.APP_INITIALIZER = APP_INITIALIZER;\nexports.ApplicationInitStatus = ApplicationInitStatus;\nexports.DebugElement = DebugElement;\nexports.DebugNode = DebugNode;\nexports.asNativeElements = asNativeElements;\nexports.getDebugNode = getDebugNode;\nexports.Testability = Testability;\nexports.TestabilityRegistry = TestabilityRegistry;\nexports.setTestabilityGetter = setTestabilityGetter;\nexports.TRANSLATIONS = TRANSLATIONS;\nexports.TRANSLATIONS_FORMAT = TRANSLATIONS_FORMAT;\nexports.LOCALE_ID = LOCALE_ID;\nexports.ApplicationModule = ApplicationModule;\nexports.wtfCreateScope = wtfCreateScope;\nexports.wtfLeave = wtfLeave;\nexports.wtfStartTimeRange = wtfStartTimeRange;\nexports.wtfEndTimeRange = wtfEndTimeRange;\nexports.Type = Type;\nexports.EventEmitter = EventEmitter;\nexports.ErrorHandler = ErrorHandler;\nexports.Sanitizer = Sanitizer;\nexports.ANALYZE_FOR_ENTRY_COMPONENTS = ANALYZE_FOR_ENTRY_COMPONENTS;\nexports.Attribute = Attribute;\nexports.ContentChild = ContentChild;\nexports.ContentChildren = ContentChildren;\nexports.Query = Query;\nexports.ViewChild = ViewChild;\nexports.ViewChildren = ViewChildren;\nexports.Component = Component;\nexports.Directive = Directive;\nexports.HostBinding = HostBinding;\nexports.HostListener = HostListener;\nexports.Input = Input;\nexports.Output = Output;\nexports.Pipe = Pipe;\nexports.CUSTOM_ELEMENTS_SCHEMA = CUSTOM_ELEMENTS_SCHEMA;\nexports.NO_ERRORS_SCHEMA = NO_ERRORS_SCHEMA;\nexports.NgModule = NgModule;\nexports.Version = Version;\nexports.VERSION = VERSION;\nexports.defineInjectable = defineInjectable;\nexports.defineInjector = defineInjector;\nexports.forwardRef = forwardRef;\nexports.resolveForwardRef = resolveForwardRef;\nexports.Injectable = Injectable;\nexports.inject = inject;\nexports.INJECTOR = INJECTOR;\nexports.Injector = Injector;\nexports.ReflectiveInjector = ReflectiveInjector;\nexports.createInjector = createInjector;\nexports.ResolvedReflectiveFactory = ResolvedReflectiveFactory;\nexports.ReflectiveKey = ReflectiveKey;\nexports.InjectionToken = InjectionToken;\nexports.Inject = Inject;\nexports.Optional = Optional;\nexports.Self = Self;\nexports.SkipSelf = SkipSelf;\nexports.Host = Host;\nexports.NgZone = NgZone;\nexports.RenderComponentType = RenderComponentType;\nexports.Renderer = Renderer;\nexports.Renderer2 = Renderer2;\nexports.RendererFactory2 = RendererFactory2;\nexports.RootRenderer = RootRenderer;\nexports.COMPILER_OPTIONS = COMPILER_OPTIONS;\nexports.Compiler = Compiler;\nexports.CompilerFactory = CompilerFactory;\nexports.ModuleWithComponentFactories = ModuleWithComponentFactories;\nexports.ComponentFactory = ComponentFactory;\nexports.ComponentRef = ComponentRef;\nexports.ComponentFactoryResolver = ComponentFactoryResolver;\nexports.ElementRef = ElementRef;\nexports.NgModuleFactory = NgModuleFactory;\nexports.NgModuleRef = NgModuleRef;\nexports.NgModuleFactoryLoader = NgModuleFactoryLoader;\nexports.getModuleFactory = getModuleFactory;\nexports.QueryList = QueryList;\nexports.SystemJsNgModuleLoader = SystemJsNgModuleLoader;\nexports.SystemJsNgModuleLoaderConfig = SystemJsNgModuleLoaderConfig;\nexports.TemplateRef = TemplateRef;\nexports.ViewContainerRef = ViewContainerRef;\nexports.EmbeddedViewRef = EmbeddedViewRef;\nexports.ViewRef = ViewRef;\nexports.ChangeDetectorRef = ChangeDetectorRef;\nexports.DefaultIterableDiffer = DefaultIterableDiffer;\nexports.IterableDiffers = IterableDiffers;\nexports.KeyValueDiffers = KeyValueDiffers;\nexports.SimpleChange = SimpleChange;\nexports.WrappedValue = WrappedValue;\nexports.platformCore = platformCore;\nexports.ɵALLOW_MULTIPLE_PLATFORMS = ALLOW_MULTIPLE_PLATFORMS;\nexports.ɵAPP_ID_RANDOM_PROVIDER = APP_ID_RANDOM_PROVIDER;\nexports.ɵdefaultIterableDiffers = defaultIterableDiffers;\nexports.ɵdevModeEqual = devModeEqual;\nexports.ɵisListLikeIterable = isListLikeIterable;\nexports.ɵisDefaultChangeDetectionStrategy = isDefaultChangeDetectionStrategy;\nexports.ɵConsole = Console;\nexports.ɵinject = inject;\nexports.ɵsetCurrentInjector = setCurrentInjector;\nexports.ɵAPP_ROOT = APP_ROOT;\nexports.ɵComponentFactory = ComponentFactory;\nexports.ɵCodegenComponentFactoryResolver = CodegenComponentFactoryResolver;\nexports.ɵReflectionCapabilities = ReflectionCapabilities;\nexports.ɵRenderDebugInfo = RenderDebugInfo;\nexports.ɵ_sanitizeHtml = _sanitizeHtml;\nexports.ɵ_sanitizeStyle = _sanitizeStyle;\nexports.ɵ_sanitizeUrl = _sanitizeUrl;\nexports.ɵglobal = _global;\nexports.ɵlooseIdentical = looseIdentical;\nexports.ɵstringify = stringify;\nexports.ɵmakeDecorator = makeDecorator;\nexports.ɵisObservable = isObservable;\nexports.ɵisPromise = isPromise;\nexports.ɵclearOverrides = clearOverrides;\nexports.ɵoverrideComponentView = overrideComponentView;\nexports.ɵoverrideProvider = overrideProvider;\nexports.ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR;\nexports.ɵdefineComponent = defineComponent;\nexports.ɵdefineDirective = defineDirective;\nexports.ɵdefinePipe = definePipe;\nexports.ɵdetectChanges = detectChanges;\nexports.ɵrenderComponent = renderComponent;\nexports.ɵdirectiveInject = directiveInject;\nexports.ɵinjectTemplateRef = injectTemplateRef;\nexports.ɵinjectViewContainerRef = injectViewContainerRef;\nexports.ɵinjectChangeDetectorRef = injectChangeDetectorRef;\nexports.ɵinjectAttribute = injectAttribute;\nexports.ɵPublicFeature = PublicFeature;\nexports.ɵNgOnChangesFeature = NgOnChangesFeature;\nexports.ɵmarkDirty = markDirty;\nexports.ɵNC = NO_CHANGE;\nexports.ɵC = container;\nexports.ɵE = elementStart;\nexports.ɵL = listener;\nexports.ɵT = text;\nexports.ɵV = embeddedViewStart;\nexports.ɵQ = query;\nexports.ɵd = loadDirective;\nexports.ɵP = projection;\nexports.ɵb = bind;\nexports.ɵi1 = interpolation1;\nexports.ɵi2 = interpolation2;\nexports.ɵi3 = interpolation3;\nexports.ɵi4 = interpolation4;\nexports.ɵi5 = interpolation5;\nexports.ɵi6 = interpolation6;\nexports.ɵi7 = interpolation7;\nexports.ɵi8 = interpolation8;\nexports.ɵiV = interpolationV;\nexports.ɵpb1 = pipeBind1;\nexports.ɵpb2 = pipeBind2;\nexports.ɵpb3 = pipeBind3;\nexports.ɵpb4 = pipeBind4;\nexports.ɵpbV = pipeBindV;\nexports.ɵf0 = pureFunction0;\nexports.ɵf1 = pureFunction1;\nexports.ɵf2 = pureFunction2;\nexports.ɵf3 = pureFunction3;\nexports.ɵf4 = pureFunction4;\nexports.ɵf5 = pureFunction5;\nexports.ɵf6 = pureFunction6;\nexports.ɵf7 = pureFunction7;\nexports.ɵf8 = pureFunction8;\nexports.ɵfV = pureFunctionV;\nexports.ɵcR = containerRefreshStart;\nexports.ɵcr = containerRefreshEnd;\nexports.ɵqR = queryRefresh;\nexports.ɵe = elementEnd;\nexports.ɵp = elementProperty;\nexports.ɵpD = projectionDef;\nexports.ɵa = elementAttribute;\nexports.ɵs = elementStyle;\nexports.ɵsn = elementStyleNamed;\nexports.ɵk = elementClass;\nexports.ɵkn = elementClassNamed;\nexports.ɵt = textBinding;\nexports.ɵv = embeddedViewEnd;\nexports.ɵst = store;\nexports.ɵld = load;\nexports.ɵPp = pipe;\nexports.ɵwhenRendered = whenRendered;\nexports.ɵbypassSanitizationTrustHtml = bypassSanitizationTrustHtml;\nexports.ɵbypassSanitizationTrustStyle = bypassSanitizationTrustStyle;\nexports.ɵbypassSanitizationTrustScript = bypassSanitizationTrustScript;\nexports.ɵbypassSanitizationTrustUrl = bypassSanitizationTrustUrl;\nexports.ɵbypassSanitizationTrustResourceUrl = bypassSanitizationTrustResourceUrl;\nexports.ɵsanitizeHtml = sanitizeHtml;\nexports.ɵsanitizeStyle = sanitizeStyle;\nexports.ɵsanitizeUrl = sanitizeUrl;\nexports.ɵsanitizeResourceUrl = sanitizeResourceUrl;\nexports.ɵregisterModuleFactory = registerModuleFactory;\nexports.ɵEMPTY_ARRAY = EMPTY_ARRAY$2;\nexports.ɵEMPTY_MAP = EMPTY_MAP;\nexports.ɵand = anchorDef;\nexports.ɵccf = createComponentFactory;\nexports.ɵcmf = createNgModuleFactory;\nexports.ɵcrt = createRendererType2;\nexports.ɵdid = directiveDef;\nexports.ɵeld = elementDef;\nexports.ɵelementEventFullName = elementEventFullName;\nexports.ɵgetComponentViewDefinitionFactory = getComponentViewDefinitionFactory;\nexports.ɵinlineInterpolate = inlineInterpolate;\nexports.ɵinterpolate = interpolate;\nexports.ɵmod = moduleDef;\nexports.ɵmpd = moduleProvideDef;\nexports.ɵncd = ngContentDef;\nexports.ɵnov = nodeValue;\nexports.ɵpid = pipeDef;\nexports.ɵprd = providerDef;\nexports.ɵpad = pureArrayDef;\nexports.ɵpod = pureObjectDef;\nexports.ɵppd = purePipeDef;\nexports.ɵqud = queryDef;\nexports.ɵted = textDef;\nexports.ɵunv = unwrapValue;\nexports.ɵvid = viewDef;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=core.umd.js.map\n"]}