@angular/core 7.2.0-beta.0 → 7.2.0

package/esm2015/src/view/types.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -9,7 +9,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-// unsupported: template constraints.
 /**
  * Factory for ViewDefinitions/NgModuleDefinitions.
  * We use a function so we can reexeute it in case an error happens and use the given logger
@@ -26,26 +25,29 @@ export function DefinitionFactory() { }
  * @record
  */
 export function NodeLogger() { }
-// unsupported: template constraints.
 /**
  * @record
  * @template DF
  */
 export function Definition() { }
-/** @type {?} */
-Definition.prototype.factory;
+if (false) {
+    /** @type {?} */
+    Definition.prototype.factory;
+}
 /**
  * @record
  */
 export function NgModuleDefinition() { }
-/** @type {?} */
-NgModuleDefinition.prototype.providers;
-/** @type {?} */
-NgModuleDefinition.prototype.providersByKey;
-/** @type {?} */
-NgModuleDefinition.prototype.modules;
-/** @type {?} */
-NgModuleDefinition.prototype.isRoot;
+if (false) {
+    /** @type {?} */
+    NgModuleDefinition.prototype.providers;
+    /** @type {?} */
+    NgModuleDefinition.prototype.providersByKey;
+    /** @type {?} */
+    NgModuleDefinition.prototype.modules;
+    /** @type {?} */
+    NgModuleDefinition.prototype.isRoot;
+}
 /**
  * @record
  */
@@ -54,40 +56,42 @@ export function NgModuleDefinitionFactory() { }
  * @record
  */
 export function ViewDefinition() { }
-/** @type {?} */
-ViewDefinition.prototype.flags;
-/** @type {?} */
-ViewDefinition.prototype.updateDirectives;
-/** @type {?} */
-ViewDefinition.prototype.updateRenderer;
-/** @type {?} */
-ViewDefinition.prototype.handleEvent;
-/**
- * Order: Depth first.
- * Especially providers are before elements / anchors.
- * @type {?}
- */
-ViewDefinition.prototype.nodes;
-/**
- * aggregated NodeFlags for all nodes *
- * @type {?}
- */
-ViewDefinition.prototype.nodeFlags;
-/** @type {?} */
-ViewDefinition.prototype.rootNodeFlags;
-/** @type {?} */
-ViewDefinition.prototype.lastRenderRootNode;
-/** @type {?} */
-ViewDefinition.prototype.bindingCount;
-/** @type {?} */
-ViewDefinition.prototype.outputCount;
-/**
- * Binary or of all query ids that are matched by one of the nodes.
- * This includes query ids from templates as well.
- * Used as a bloom filter.
- * @type {?}
- */
-ViewDefinition.prototype.nodeMatchedQueries;
+if (false) {
+    /** @type {?} */
+    ViewDefinition.prototype.flags;
+    /** @type {?} */
+    ViewDefinition.prototype.updateDirectives;
+    /** @type {?} */
+    ViewDefinition.prototype.updateRenderer;
+    /** @type {?} */
+    ViewDefinition.prototype.handleEvent;
+    /**
+     * Order: Depth first.
+     * Especially providers are before elements / anchors.
+     * @type {?}
+     */
+    ViewDefinition.prototype.nodes;
+    /**
+     * aggregated NodeFlags for all nodes *
+     * @type {?}
+     */
+    ViewDefinition.prototype.nodeFlags;
+    /** @type {?} */
+    ViewDefinition.prototype.rootNodeFlags;
+    /** @type {?} */
+    ViewDefinition.prototype.lastRenderRootNode;
+    /** @type {?} */
+    ViewDefinition.prototype.bindingCount;
+    /** @type {?} */
+    ViewDefinition.prototype.outputCount;
+    /**
+     * Binary or of all query ids that are matched by one of the nodes.
+     * This includes query ids from templates as well.
+     * Used as a bloom filter.
+     * @type {?}
+     */
+    ViewDefinition.prototype.nodeMatchedQueries;
+}
 /**
  * @record
  */
@@ -101,7 +105,7 @@ export function ViewUpdateFn() { }
  */
 export function NodeCheckFn() { }
 /** @enum {number} */
-var ArgumentType = {
+const ArgumentType = {
     Inline: 0, Dynamic: 1,
 };
 export { ArgumentType };
@@ -110,7 +114,7 @@ export { ArgumentType };
  */
 export function ViewHandleEventFn() { }
 /** @enum {number} */
-var ViewFlags = {
+const ViewFlags = {
     None: 0,
     OnPush: 2,
 };
@@ -123,80 +127,82 @@ export { ViewFlags };
  * @record
  */
 export function NodeDef() { }
-/** @type {?} */
-NodeDef.prototype.flags;
-/** @type {?} */
-NodeDef.prototype.nodeIndex;
-/** @type {?} */
-NodeDef.prototype.checkIndex;
-/** @type {?} */
-NodeDef.prototype.parent;
-/** @type {?} */
-NodeDef.prototype.renderParent;
-/**
- * this is checked against NgContentDef.index to find matched nodes
- * @type {?}
- */
-NodeDef.prototype.ngContentIndex;
-/**
- * number of transitive children
- * @type {?}
- */
-NodeDef.prototype.childCount;
-/**
- * aggregated NodeFlags for all transitive children (does not include self) *
- * @type {?}
- */
-NodeDef.prototype.childFlags;
-/**
- * aggregated NodeFlags for all direct children (does not include self) *
- * @type {?}
- */
-NodeDef.prototype.directChildFlags;
-/** @type {?} */
-NodeDef.prototype.bindingIndex;
-/** @type {?} */
-NodeDef.prototype.bindings;
-/** @type {?} */
-NodeDef.prototype.bindingFlags;
-/** @type {?} */
-NodeDef.prototype.outputIndex;
-/** @type {?} */
-NodeDef.prototype.outputs;
-/**
- * references that the user placed on the element
- * @type {?}
- */
-NodeDef.prototype.references;
-/**
- * ids and value types of all queries that are matched by this node.
- * @type {?}
- */
-NodeDef.prototype.matchedQueries;
-/**
- * Binary or of all matched query ids of this node.
- * @type {?}
- */
-NodeDef.prototype.matchedQueryIds;
-/**
- * Binary or of all query ids that are matched by one of the children.
- * This includes query ids from templates as well.
- * Used as a bloom filter.
- * @type {?}
- */
-NodeDef.prototype.childMatchedQueries;
-/** @type {?} */
-NodeDef.prototype.element;
-/** @type {?} */
-NodeDef.prototype.provider;
-/** @type {?} */
-NodeDef.prototype.text;
-/** @type {?} */
-NodeDef.prototype.query;
-/** @type {?} */
-NodeDef.prototype.ngContent;
+if (false) {
+    /** @type {?} */
+    NodeDef.prototype.flags;
+    /** @type {?} */
+    NodeDef.prototype.nodeIndex;
+    /** @type {?} */
+    NodeDef.prototype.checkIndex;
+    /** @type {?} */
+    NodeDef.prototype.parent;
+    /** @type {?} */
+    NodeDef.prototype.renderParent;
+    /**
+     * this is checked against NgContentDef.index to find matched nodes
+     * @type {?}
+     */
+    NodeDef.prototype.ngContentIndex;
+    /**
+     * number of transitive children
+     * @type {?}
+     */
+    NodeDef.prototype.childCount;
+    /**
+     * aggregated NodeFlags for all transitive children (does not include self) *
+     * @type {?}
+     */
+    NodeDef.prototype.childFlags;
+    /**
+     * aggregated NodeFlags for all direct children (does not include self) *
+     * @type {?}
+     */
+    NodeDef.prototype.directChildFlags;
+    /** @type {?} */
+    NodeDef.prototype.bindingIndex;
+    /** @type {?} */
+    NodeDef.prototype.bindings;
+    /** @type {?} */
+    NodeDef.prototype.bindingFlags;
+    /** @type {?} */
+    NodeDef.prototype.outputIndex;
+    /** @type {?} */
+    NodeDef.prototype.outputs;
+    /**
+     * references that the user placed on the element
+     * @type {?}
+     */
+    NodeDef.prototype.references;
+    /**
+     * ids and value types of all queries that are matched by this node.
+     * @type {?}
+     */
+    NodeDef.prototype.matchedQueries;
+    /**
+     * Binary or of all matched query ids of this node.
+     * @type {?}
+     */
+    NodeDef.prototype.matchedQueryIds;
+    /**
+     * Binary or of all query ids that are matched by one of the children.
+     * This includes query ids from templates as well.
+     * Used as a bloom filter.
+     * @type {?}
+     */
+    NodeDef.prototype.childMatchedQueries;
+    /** @type {?} */
+    NodeDef.prototype.element;
+    /** @type {?} */
+    NodeDef.prototype.provider;
+    /** @type {?} */
+    NodeDef.prototype.text;
+    /** @type {?} */
+    NodeDef.prototype.query;
+    /** @type {?} */
+    NodeDef.prototype.ngContent;
+}
 /** @enum {number} */
-var NodeFlags = {
+const NodeFlags = {
     None: 0,
     TypeElement: 1,
     TypeText: 2,
@@ -242,20 +248,22 @@ export { NodeFlags };
  * @record
  */
 export function BindingDef() { }
-/** @type {?} */
-BindingDef.prototype.flags;
-/** @type {?} */
-BindingDef.prototype.ns;
-/** @type {?} */
-BindingDef.prototype.name;
-/** @type {?} */
-BindingDef.prototype.nonMinifiedName;
-/** @type {?} */
-BindingDef.prototype.securityContext;
-/** @type {?} */
-BindingDef.prototype.suffix;
+if (false) {
+    /** @type {?} */
+    BindingDef.prototype.flags;
+    /** @type {?} */
+    BindingDef.prototype.ns;
+    /** @type {?} */
+    BindingDef.prototype.name;
+    /** @type {?} */
+    BindingDef.prototype.nonMinifiedName;
+    /** @type {?} */
+    BindingDef.prototype.securityContext;
+    /** @type {?} */
+    BindingDef.prototype.suffix;
+}
 /** @enum {number} */
-var BindingFlags = {
+const BindingFlags = {
     TypeElementAttribute: 1,
     TypeElementClass: 2,
     TypeElementStyle: 4,
@@ -271,21 +279,23 @@ export { BindingFlags };
  * @record
  */
 export function OutputDef() { }
-/** @type {?} */
-OutputDef.prototype.type;
-/** @type {?} */
-OutputDef.prototype.target;
-/** @type {?} */
-OutputDef.prototype.eventName;
-/** @type {?} */
-OutputDef.prototype.propName;
+if (false) {
+    /** @type {?} */
+    OutputDef.prototype.type;
+    /** @type {?} */
+    OutputDef.prototype.target;
+    /** @type {?} */
+    OutputDef.prototype.eventName;
+    /** @type {?} */
+    OutputDef.prototype.propName;
+}
 /** @enum {number} */
-var OutputType = {
+const OutputType = {
     ElementOutput: 0, DirectiveOutput: 1,
 };
 export { OutputType };
 /** @enum {number} */
-var QueryValueType = {
+const QueryValueType = {
     ElementRef: 0,
     RenderElement: 1,
     TemplateRef: 2,
@@ -297,37 +307,39 @@ export { QueryValueType };
  * @record
  */
 export function ElementDef() { }
-/** @type {?} */
-ElementDef.prototype.name;
-/** @type {?} */
-ElementDef.prototype.ns;
-/**
- * ns, name, value
- * @type {?}
- */
-ElementDef.prototype.attrs;
-/** @type {?} */
-ElementDef.prototype.template;
-/** @type {?} */
-ElementDef.prototype.componentProvider;
-/** @type {?} */
-ElementDef.prototype.componentRendererType;
-/** @type {?} */
-ElementDef.prototype.componentView;
-/**
- * visible public providers for DI in the view,
- * as see from this element. This does not include private providers.
- * @type {?}
- */
-ElementDef.prototype.publicProviders;
-/**
- * same as visiblePublicProviders, but also includes private providers
- * that are located on this element.
- * @type {?}
- */
-ElementDef.prototype.allProviders;
-/** @type {?} */
-ElementDef.prototype.handleEvent;
+if (false) {
+    /** @type {?} */
+    ElementDef.prototype.name;
+    /** @type {?} */
+    ElementDef.prototype.ns;
+    /**
+     * ns, name, value
+     * @type {?}
+     */
+    ElementDef.prototype.attrs;
+    /** @type {?} */
+    ElementDef.prototype.template;
+    /** @type {?} */
+    ElementDef.prototype.componentProvider;
+    /** @type {?} */
+    ElementDef.prototype.componentRendererType;
+    /** @type {?} */
+    ElementDef.prototype.componentView;
+    /**
+     * visible public providers for DI in the view,
+     * as see from this element. This does not include private providers.
+     * @type {?}
+     */
+    ElementDef.prototype.publicProviders;
+    /**
+     * same as visiblePublicProviders, but also includes private providers
+     * that are located on this element.
+     * @type {?}
+     */
+    ElementDef.prototype.allProviders;
+    /** @type {?} */
+    ElementDef.prototype.handleEvent;
+}
 /**
  * @record
  */
@@ -336,38 +348,44 @@ export function ElementHandleEventFn() { }
  * @record
  */
 export function ProviderDef() { }
-/** @type {?} */
-ProviderDef.prototype.token;
-/** @type {?} */
-ProviderDef.prototype.value;
-/** @type {?} */
-ProviderDef.prototype.deps;
+if (false) {
+    /** @type {?} */
+    ProviderDef.prototype.token;
+    /** @type {?} */
+    ProviderDef.prototype.value;
+    /** @type {?} */
+    ProviderDef.prototype.deps;
+}
 /**
  * @record
  */
 export function NgModuleProviderDef() { }
-/** @type {?} */
-NgModuleProviderDef.prototype.flags;
-/** @type {?} */
-NgModuleProviderDef.prototype.index;
-/** @type {?} */
-NgModuleProviderDef.prototype.token;
-/** @type {?} */
-NgModuleProviderDef.prototype.value;
-/** @type {?} */
-NgModuleProviderDef.prototype.deps;
+if (false) {
+    /** @type {?} */
+    NgModuleProviderDef.prototype.flags;
+    /** @type {?} */
+    NgModuleProviderDef.prototype.index;
+    /** @type {?} */
+    NgModuleProviderDef.prototype.token;
+    /** @type {?} */
+    NgModuleProviderDef.prototype.value;
+    /** @type {?} */
+    NgModuleProviderDef.prototype.deps;
+}
 /**
  * @record
  */
 export function DepDef() { }
-/** @type {?} */
-DepDef.prototype.flags;
-/** @type {?} */
-DepDef.prototype.token;
-/** @type {?} */
-DepDef.prototype.tokenKey;
+if (false) {
+    /** @type {?} */
+    DepDef.prototype.flags;
+    /** @type {?} */
+    DepDef.prototype.token;
+    /** @type {?} */
+    DepDef.prototype.tokenKey;
+}
 /** @enum {number} */
-var DepFlags = {
+const DepFlags = {
     None: 0,
     SkipSelf: 1,
     Optional: 2,
@@ -379,28 +397,34 @@ export { DepFlags };
  * @record
  */
 export function TextDef() { }
-/** @type {?} */
-TextDef.prototype.prefix;
+if (false) {
+    /** @type {?} */
+    TextDef.prototype.prefix;
+}
 /**
  * @record
  */
 export function QueryDef() { }
-/** @type {?} */
-QueryDef.prototype.id;
-/** @type {?} */
-QueryDef.prototype.filterId;
-/** @type {?} */
-QueryDef.prototype.bindings;
+if (false) {
+    /** @type {?} */
+    QueryDef.prototype.id;
+    /** @type {?} */
+    QueryDef.prototype.filterId;
+    /** @type {?} */
+    QueryDef.prototype.bindings;
+}
 /**
  * @record
  */
 export function QueryBindingDef() { }
-/** @type {?} */
-QueryBindingDef.prototype.propName;
-/** @type {?} */
-QueryBindingDef.prototype.bindingType;
+if (false) {
+    /** @type {?} */
+    QueryBindingDef.prototype.propName;
+    /** @type {?} */
+    QueryBindingDef.prototype.bindingType;
+}
 /** @enum {number} */
-var QueryBindingType = {
+const QueryBindingType = {
     First: 0, All: 1,
 };
 export { QueryBindingType };
@@ -408,58 +432,64 @@ export { QueryBindingType };
  * @record
  */
 export function NgContentDef() { }
-/**
- * this index is checked against NodeDef.ngContentIndex to find the nodes
- * that are matched by this ng-content.
- * Note that a NodeDef with an ng-content can be reprojected, i.e.
- * have a ngContentIndex on its own.
- * @type {?}
- */
-NgContentDef.prototype.index;
+if (false) {
+    /**
+     * this index is checked against NodeDef.ngContentIndex to find the nodes
+     * that are matched by this ng-content.
+     * Note that a NodeDef with an ng-content can be reprojected, i.e.
+     * have a ngContentIndex on its own.
+     * @type {?}
+     */
+    NgContentDef.prototype.index;
+}
 /**
  * @record
  */
 export function NgModuleData() { }
-/** @type {?} */
-NgModuleData.prototype._def;
-/** @type {?} */
-NgModuleData.prototype._parent;
-/** @type {?} */
-NgModuleData.prototype._providers;
+if (false) {
+    /** @type {?} */
+    NgModuleData.prototype._def;
+    /** @type {?} */
+    NgModuleData.prototype._parent;
+    /** @type {?} */
+    NgModuleData.prototype._providers;
+}
 /**
  * View instance data.
  * Attention: Adding fields to this is performance sensitive!
  * @record
  */
 export function ViewData() { }
-/** @type {?} */
-ViewData.prototype.def;
-/** @type {?} */
-ViewData.prototype.root;
-/** @type {?} */
-ViewData.prototype.renderer;
-/** @type {?} */
-ViewData.prototype.parentNodeDef;
-/** @type {?} */
-ViewData.prototype.parent;
-/** @type {?} */
-ViewData.prototype.viewContainerParent;
-/** @type {?} */
-ViewData.prototype.component;
-/** @type {?} */
-ViewData.prototype.context;
-/** @type {?} */
-ViewData.prototype.nodes;
-/** @type {?} */
-ViewData.prototype.state;
-/** @type {?} */
-ViewData.prototype.oldValues;
-/** @type {?} */
-ViewData.prototype.disposables;
-/** @type {?} */
-ViewData.prototype.initIndex;
+if (false) {
+    /** @type {?} */
+    ViewData.prototype.def;
+    /** @type {?} */
+    ViewData.prototype.root;
+    /** @type {?} */
+    ViewData.prototype.renderer;
+    /** @type {?} */
+    ViewData.prototype.parentNodeDef;
+    /** @type {?} */
+    ViewData.prototype.parent;
+    /** @type {?} */
+    ViewData.prototype.viewContainerParent;
+    /** @type {?} */
+    ViewData.prototype.component;
+    /** @type {?} */
+    ViewData.prototype.context;
+    /** @type {?} */
+    ViewData.prototype.nodes;
+    /** @type {?} */
+    ViewData.prototype.state;
+    /** @type {?} */
+    ViewData.prototype.oldValues;
+    /** @type {?} */
+    ViewData.prototype.disposables;
+    /** @type {?} */
+    ViewData.prototype.initIndex;
+}
 /** @enum {number} */
-var ViewState = {
+const ViewState = {
     BeforeFirstCheck: 1,
     FirstCheck: 2,
     Attached: 4,
@@ -479,6 +509,10 @@ var ViewState = {
     CatInit: 13,
 };
 export { ViewState };
+// Called before each cycle of a view's check to detect whether this is in the
+// initState for which we need to call ngOnInit, ngAfterContentInit or ngAfterViewInit
+// lifecycle methods. Returns true if this check cycle should call lifecycle
+// methods.
 /**
  * @param {?} view
  * @param {?} priorInitState
@@ -486,6 +520,15 @@ export { ViewState };
  * @return {?}
  */
 export function shiftInitState(view, priorInitState, newInitState) {
+    // Only update the InitState if we are currently in the prior state.
+    // For example, only move into CallingInit if we are in BeforeInit. Only
+    // move into CallingContentInit if we are in CallingInit. Normally this will
+    // always be true because of how checkCycle is called in checkAndUpdateView.
+    // However, if checkAndUpdateView is called recursively or if an exception is
+    // thrown while checkAndUpdateView is running, checkAndUpdateView starts over
+    // from the beginning. This ensures the state is monotonically increasing,
+    // terminating in the AfterInit state, which ensures the Init methods are called
+    // at least once and only once.
     /** @type {?} */
     const state = view.state;
     /** @type {?} */
@@ -497,6 +540,8 @@ export function shiftInitState(view, priorInitState, newInitState) {
     }
     return initState === newInitState;
 }
+// Returns true if the lifecycle init method should be called for the node with
+// the given init index.
 /**
  * @param {?} view
  * @param {?} initState
@@ -528,7 +573,10 @@ export function DisposableFn() { }
 export class NodeData {
 }
 if (false) {
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     NodeData.prototype.__brand;
 }
 /**
@@ -538,8 +586,10 @@ if (false) {
  * @record
  */
 export function TextData() { }
-/** @type {?} */
-TextData.prototype.renderText;
+if (false) {
+    /** @type {?} */
+    TextData.prototype.renderText;
+}
 /**
  * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
  * @param {?} view
@@ -547,7 +597,7 @@ TextData.prototype.renderText;
  * @return {?}
  */
 export function asTextData(view, index) {
-    return /** @type {?} */ (view.nodes[index]);
+    return (/** @type {?} */ (view.nodes[index]));
 }
 /**
  * Data for an instantiated NodeType.Element.
@@ -556,26 +606,32 @@ export function asTextData(view, index) {
  * @record
  */
 export function ElementData() { }
-/** @type {?} */
-ElementData.prototype.renderElement;
-/** @type {?} */
-ElementData.prototype.componentView;
-/** @type {?} */
-ElementData.prototype.viewContainer;
-/** @type {?} */
-ElementData.prototype.template;
+if (false) {
+    /** @type {?} */
+    ElementData.prototype.renderElement;
+    /** @type {?} */
+    ElementData.prototype.componentView;
+    /** @type {?} */
+    ElementData.prototype.viewContainer;
+    /** @type {?} */
+    ElementData.prototype.template;
+}
 /**
  * @record
  */
 export function ViewContainerData() { }
-/** @type {?} */
-ViewContainerData.prototype._embeddedViews;
+if (false) {
+    /** @type {?} */
+    ViewContainerData.prototype._embeddedViews;
+}
 /**
  * @record
  */
 export function TemplateData() { }
-/** @type {?} */
-TemplateData.prototype._projectedViews;
+if (false) {
+    /** @type {?} */
+    TemplateData.prototype._projectedViews;
+}
 /**
  * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
  * @param {?} view
@@ -583,7 +639,7 @@ TemplateData.prototype._projectedViews;
  * @return {?}
  */
 export function asElementData(view, index) {
-    return /** @type {?} */ (view.nodes[index]);
+    return (/** @type {?} */ (view.nodes[index]));
 }
 /**
  * Data for an instantiated NodeType.Provider.
@@ -592,8 +648,10 @@ export function asElementData(view, index) {
  * @record
  */
 export function ProviderData() { }
-/** @type {?} */
-ProviderData.prototype.instance;
+if (false) {
+    /** @type {?} */
+    ProviderData.prototype.instance;
+}
 /**
  * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
  * @param {?} view
@@ -601,7 +659,7 @@ ProviderData.prototype.instance;
  * @return {?}
  */
 export function asProviderData(view, index) {
-    return /** @type {?} */ (view.nodes[index]);
+    return (/** @type {?} */ (view.nodes[index]));
 }
 /**
  * Data for an instantiated NodeType.PureExpression.
@@ -610,8 +668,10 @@ export function asProviderData(view, index) {
  * @record
  */
 export function PureExpressionData() { }
-/** @type {?} */
-PureExpressionData.prototype.value;
+if (false) {
+    /** @type {?} */
+    PureExpressionData.prototype.value;
+}
 /**
  * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
  * @param {?} view
@@ -619,7 +679,7 @@ PureExpressionData.prototype.value;
  * @return {?}
  */
 export function asPureExpressionData(view, index) {
-    return /** @type {?} */ (view.nodes[index]);
+    return (/** @type {?} */ (view.nodes[index]));
 }
 /**
  * Accessor for view.nodes, enforcing that every usage site stays monomorphic.
@@ -628,28 +688,30 @@ export function asPureExpressionData(view, index) {
  * @return {?}
  */
 export function asQueryList(view, index) {
-    return /** @type {?} */ (view.nodes[index]);
+    return (/** @type {?} */ (view.nodes[index]));
 }
 /**
  * @record
  */
 export function RootData() { }
-/** @type {?} */
-RootData.prototype.injector;
-/** @type {?} */
-RootData.prototype.ngModule;
-/** @type {?} */
-RootData.prototype.projectableNodes;
-/** @type {?} */
-RootData.prototype.selectorOrNode;
-/** @type {?} */
-RootData.prototype.renderer;
-/** @type {?} */
-RootData.prototype.rendererFactory;
-/** @type {?} */
-RootData.prototype.errorHandler;
-/** @type {?} */
-RootData.prototype.sanitizer;
+if (false) {
+    /** @type {?} */
+    RootData.prototype.injector;
+    /** @type {?} */
+    RootData.prototype.ngModule;
+    /** @type {?} */
+    RootData.prototype.projectableNodes;
+    /** @type {?} */
+    RootData.prototype.selectorOrNode;
+    /** @type {?} */
+    RootData.prototype.renderer;
+    /** @type {?} */
+    RootData.prototype.rendererFactory;
+    /** @type {?} */
+    RootData.prototype.errorHandler;
+    /** @type {?} */
+    RootData.prototype.sanitizer;
+}
 /**
  * @abstract
  */
@@ -710,7 +772,7 @@ if (false) {
     DebugContext.prototype.logError = function (console, values) { };
 }
 /** @enum {number} */
-var CheckType = {
+const CheckType = {
     CheckAndUpdate: 0, CheckNoChanges: 1,
 };
 export { CheckType };
@@ -718,38 +780,41 @@ export { CheckType };
  * @record
  */
 export function ProviderOverride() { }
-/** @type {?} */
-ProviderOverride.prototype.token;
-/** @type {?} */
-ProviderOverride.prototype.flags;
-/** @type {?} */
-ProviderOverride.prototype.value;
-/** @type {?} */
-ProviderOverride.prototype.deps;
-/** @type {?} */
-ProviderOverride.prototype.deprecatedBehavior;
-/** *
+if (false) {
+    /** @type {?} */
+    ProviderOverride.prototype.token;
+    /** @type {?} */
+    ProviderOverride.prototype.flags;
+    /** @type {?} */
+    ProviderOverride.prototype.value;
+    /** @type {?} */
+    ProviderOverride.prototype.deps;
+    /** @type {?} */
+    ProviderOverride.prototype.deprecatedBehavior;
+}
+// WARNING: interface has both a type and a value, skipping emit
+/**
  * This object is used to prevent cycles in the source files and to have a place where
  * debug mode can hook it. It is lazily filled when `isDevMode` is known.
-  @type {?} */
+ * @type {?}
+ */
 export const Services = {
-    setCurrentNode: /** @type {?} */ ((undefined)),
-    createRootView: /** @type {?} */ ((undefined)),
-    createEmbeddedView: /** @type {?} */ ((undefined)),
-    createComponentView: /** @type {?} */ ((undefined)),
-    createNgModuleRef: /** @type {?} */ ((undefined)),
-    overrideProvider: /** @type {?} */ ((undefined)),
-    overrideComponentView: /** @type {?} */ ((undefined)),
-    clearOverrides: /** @type {?} */ ((undefined)),
-    checkAndUpdateView: /** @type {?} */ ((undefined)),
-    checkNoChangesView: /** @type {?} */ ((undefined)),
-    destroyView: /** @type {?} */ ((undefined)),
-    resolveDep: /** @type {?} */ ((undefined)),
-    createDebugContext: /** @type {?} */ ((undefined)),
-    handleEvent: /** @type {?} */ ((undefined)),
-    updateDirectives: /** @type {?} */ ((undefined)),
-    updateRenderer: /** @type {?} */ ((undefined)),
-    dirtyParentQueries: /** @type {?} */ ((undefined)),
+    setCurrentNode: (/** @type {?} */ (undefined)),
+    createRootView: (/** @type {?} */ (undefined)),
+    createEmbeddedView: (/** @type {?} */ (undefined)),
+    createComponentView: (/** @type {?} */ (undefined)),
+    createNgModuleRef: (/** @type {?} */ (undefined)),
+    overrideProvider: (/** @type {?} */ (undefined)),
+    overrideComponentView: (/** @type {?} */ (undefined)),
+    clearOverrides: (/** @type {?} */ (undefined)),
+    checkAndUpdateView: (/** @type {?} */ (undefined)),
+    checkNoChangesView: (/** @type {?} */ (undefined)),
+    destroyView: (/** @type {?} */ (undefined)),
+    resolveDep: (/** @type {?} */ (undefined)),
+    createDebugContext: (/** @type {?} */ (undefined)),
+    handleEvent: (/** @type {?} */ (undefined)),
+    updateDirectives: (/** @type {?} */ (undefined)),
+    updateRenderer: (/** @type {?} */ (undefined)),
+    dirtyParentQueries: (/** @type {?} */ (undefined)),
 };
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/view/types.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector} from '../di';\nimport {ErrorHandler} from '../error_handler';\nimport {ComponentFactory} from '../linker/component_factory';\nimport {NgModuleRef} from '../linker/ng_module_factory';\nimport {QueryList} from '../linker/query_list';\nimport {TemplateRef} from '../linker/template_ref';\nimport {ViewContainerRef} from '../linker/view_container_ref';\nimport {Renderer2, RendererFactory2, RendererType2} from '../render/api';\nimport {Sanitizer, SecurityContext} from '../sanitization/security';\nimport {Type} from '../type';\n\n\n// -------------------------------------\n// Defs\n// -------------------------------------\n\n/**\n * Factory for ViewDefinitions/NgModuleDefinitions.\n * We use a function so we can reexeute it in case an error happens and use the given logger\n * function to log the error from the definition of the node, which is shown in all browser\n * logs.\n */\nexport interface DefinitionFactory<D extends Definition<any>> { (logger: NodeLogger): D; }\n\n/**\n * Function to call console.error at the right source location. This is an indirection\n * via another function as browser will log the location that actually called\n * `console.error`.\n */\nexport interface NodeLogger { (): () => void; }\n\nexport interface Definition<DF extends DefinitionFactory<any>> { factory: DF|null; }\n\nexport interface NgModuleDefinition extends Definition<NgModuleDefinitionFactory> {\n  providers: NgModuleProviderDef[];\n  providersByKey: {[tokenKey: string]: NgModuleProviderDef};\n  modules: any[];\n  isRoot: boolean;\n}\n\nexport interface NgModuleDefinitionFactory extends DefinitionFactory<NgModuleDefinition> {}\n\nexport interface ViewDefinition extends Definition<ViewDefinitionFactory> {\n  flags: ViewFlags;\n  updateDirectives: ViewUpdateFn;\n  updateRenderer: ViewUpdateFn;\n  handleEvent: ViewHandleEventFn;\n  /**\n   * Order: Depth first.\n   * Especially providers are before elements / anchors.\n   */\n  nodes: NodeDef[];\n  /** aggregated NodeFlags for all nodes **/\n  nodeFlags: NodeFlags;\n  rootNodeFlags: NodeFlags;\n  lastRenderRootNode: NodeDef|null;\n  bindingCount: number;\n  outputCount: number;\n  /**\n   * Binary or of all query ids that are matched by one of the nodes.\n   * This includes query ids from templates as well.\n   * Used as a bloom filter.\n   */\n  nodeMatchedQueries: number;\n}\n\nexport interface ViewDefinitionFactory extends DefinitionFactory<ViewDefinition> {}\n\n\nexport interface ViewUpdateFn { (check: NodeCheckFn, view: ViewData): void; }\n\n// helper functions to create an overloaded function type.\nexport interface NodeCheckFn {\n  (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Dynamic, values: any[]): any;\n\n  (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Inline, v0?: any, v1?: any, v2?: any,\n   v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any;\n}\n\nexport const enum ArgumentType {Inline = 0, Dynamic = 1}\n\nexport interface ViewHandleEventFn {\n  (view: ViewData, nodeIndex: number, eventName: string, event: any): boolean;\n}\n\n/**\n * Bitmask for ViewDefinition.flags.\n */\nexport const enum ViewFlags {\n  None = 0,\n  OnPush = 1 << 1,\n}\n\n/**\n * A node definition in the view.\n *\n * Note: We use one type for all nodes so that loops that loop over all nodes\n * of a ViewDefinition stay monomorphic!\n */\nexport interface NodeDef {\n  flags: NodeFlags;\n  // Index of the node in view data and view definition (those are the same)\n  nodeIndex: number;\n  // Index of the node in the check functions\n  // Differ from nodeIndex when nodes are added or removed at runtime (ie after compilation)\n  checkIndex: number;\n  parent: NodeDef|null;\n  renderParent: NodeDef|null;\n  /** this is checked against NgContentDef.index to find matched nodes */\n  ngContentIndex: number|null;\n  /** number of transitive children */\n  childCount: number;\n  /** aggregated NodeFlags for all transitive children (does not include self) **/\n  childFlags: NodeFlags;\n  /** aggregated NodeFlags for all direct children (does not include self) **/\n  directChildFlags: NodeFlags;\n\n  bindingIndex: number;\n  bindings: BindingDef[];\n  bindingFlags: BindingFlags;\n  outputIndex: number;\n  outputs: OutputDef[];\n  /**\n   * references that the user placed on the element\n   */\n  references: {[refId: string]: QueryValueType};\n  /**\n   * ids and value types of all queries that are matched by this node.\n   */\n  matchedQueries: {[queryId: number]: QueryValueType};\n  /** Binary or of all matched query ids of this node. */\n  matchedQueryIds: number;\n  /**\n   * Binary or of all query ids that are matched by one of the children.\n   * This includes query ids from templates as well.\n   * Used as a bloom filter.\n   */\n  childMatchedQueries: number;\n  element: ElementDef|null;\n  provider: ProviderDef|null;\n  text: TextDef|null;\n  query: QueryDef|null;\n  ngContent: NgContentDef|null;\n}\n\n/**\n * Bitmask for NodeDef.flags.\n * Naming convention:\n * - `Type...`: flags that are mutually exclusive\n * - `Cat...`: union of multiple `Type...` (short for category).\n */\nexport const enum NodeFlags {\n  None = 0,\n  TypeElement = 1 << 0,\n  TypeText = 1 << 1,\n  ProjectedTemplate = 1 << 2,\n  CatRenderNode = TypeElement | TypeText,\n  TypeNgContent = 1 << 3,\n  TypePipe = 1 << 4,\n  TypePureArray = 1 << 5,\n  TypePureObject = 1 << 6,\n  TypePurePipe = 1 << 7,\n  CatPureExpression = TypePureArray | TypePureObject | TypePurePipe,\n  TypeValueProvider = 1 << 8,\n  TypeClassProvider = 1 << 9,\n  TypeFactoryProvider = 1 << 10,\n  TypeUseExistingProvider = 1 << 11,\n  LazyProvider = 1 << 12,\n  PrivateProvider = 1 << 13,\n  TypeDirective = 1 << 14,\n  Component = 1 << 15,\n  CatProviderNoDirective =\n      TypeValueProvider | TypeClassProvider | TypeFactoryProvider | TypeUseExistingProvider,\n  CatProvider = CatProviderNoDirective | TypeDirective,\n  OnInit = 1 << 16,\n  OnDestroy = 1 << 17,\n  DoCheck = 1 << 18,\n  OnChanges = 1 << 19,\n  AfterContentInit = 1 << 20,\n  AfterContentChecked = 1 << 21,\n  AfterViewInit = 1 << 22,\n  AfterViewChecked = 1 << 23,\n  EmbeddedViews = 1 << 24,\n  ComponentView = 1 << 25,\n  TypeContentQuery = 1 << 26,\n  TypeViewQuery = 1 << 27,\n  StaticQuery = 1 << 28,\n  DynamicQuery = 1 << 29,\n  TypeNgModule = 1 << 30,\n  CatQuery = TypeContentQuery | TypeViewQuery,\n\n  // mutually exclusive values...\n  Types = CatRenderNode | TypeNgContent | TypePipe | CatPureExpression | CatProvider | CatQuery\n}\n\nexport interface BindingDef {\n  flags: BindingFlags;\n  ns: string|null;\n  name: string|null;\n  nonMinifiedName: string|null;\n  securityContext: SecurityContext|null;\n  suffix: string|null;\n}\n\nexport const enum BindingFlags {\n  TypeElementAttribute = 1 << 0,\n  TypeElementClass = 1 << 1,\n  TypeElementStyle = 1 << 2,\n  TypeProperty = 1 << 3,\n  SyntheticProperty = 1 << 4,\n  SyntheticHostProperty = 1 << 5,\n  CatSyntheticProperty = SyntheticProperty | SyntheticHostProperty,\n\n  // mutually exclusive values...\n  Types = TypeElementAttribute | TypeElementClass | TypeElementStyle | TypeProperty\n}\n\nexport interface OutputDef {\n  type: OutputType;\n  target: 'window'|'document'|'body'|'component'|null;\n  eventName: string;\n  propName: string|null;\n}\n\nexport const enum OutputType {ElementOutput, DirectiveOutput}\n\nexport const enum QueryValueType {\n  ElementRef = 0,\n  RenderElement = 1,\n  TemplateRef = 2,\n  ViewContainerRef = 3,\n  Provider = 4\n}\n\nexport interface ElementDef {\n  // set to null for `<ng-container>`\n  name: string|null;\n  ns: string|null;\n  /** ns, name, value */\n  attrs: [string, string, string][]|null;\n  template: ViewDefinition|null;\n  componentProvider: NodeDef|null;\n  componentRendererType: RendererType2|null;\n  // closure to allow recursive components\n  componentView: ViewDefinitionFactory|null;\n  /**\n   * visible public providers for DI in the view,\n   * as see from this element. This does not include private providers.\n   */\n  publicProviders: {[tokenKey: string]: NodeDef}|null;\n  /**\n   * same as visiblePublicProviders, but also includes private providers\n   * that are located on this element.\n   */\n  allProviders: {[tokenKey: string]: NodeDef}|null;\n  handleEvent: ElementHandleEventFn|null;\n}\n\nexport interface ElementHandleEventFn { (view: ViewData, eventName: string, event: any): boolean; }\n\nexport interface ProviderDef {\n  token: any;\n  value: any;\n  deps: DepDef[];\n}\n\nexport interface NgModuleProviderDef {\n  flags: NodeFlags;\n  index: number;\n  token: any;\n  value: any;\n  deps: DepDef[];\n}\n\nexport interface DepDef {\n  flags: DepFlags;\n  token: any;\n  tokenKey: string;\n}\n\n/**\n * Bitmask for DI flags\n */\nexport const enum DepFlags {\n  None = 0,\n  SkipSelf = 1 << 0,\n  Optional = 1 << 1,\n  Self = 1 << 2,\n  Value = 1 << 3,\n}\n\nexport interface TextDef { prefix: string; }\n\nexport interface QueryDef {\n  id: number;\n  // variant of the id that can be used to check against NodeDef.matchedQueryIds, ...\n  filterId: number;\n  bindings: QueryBindingDef[];\n}\n\nexport interface QueryBindingDef {\n  propName: string;\n  bindingType: QueryBindingType;\n}\n\nexport const enum QueryBindingType {First = 0, All = 1}\n\nexport interface NgContentDef {\n  /**\n   * this index is checked against NodeDef.ngContentIndex to find the nodes\n   * that are matched by this ng-content.\n   * Note that a NodeDef with an ng-content can be reprojected, i.e.\n   * have a ngContentIndex on its own.\n   */\n  index: number;\n}\n\n// -------------------------------------\n// Data\n// -------------------------------------\n\nexport interface NgModuleData extends Injector, NgModuleRef<any> {\n  // Note: we are using the prefix _ as NgModuleData is an NgModuleRef and therefore directly\n  // exposed to the user.\n  _def: NgModuleDefinition;\n  _parent: Injector;\n  _providers: any[];\n}\n\n/**\n * View instance data.\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ViewData {\n  def: ViewDefinition;\n  root: RootData;\n  renderer: Renderer2;\n  // index of component provider / anchor.\n  parentNodeDef: NodeDef|null;\n  parent: ViewData|null;\n  viewContainerParent: ViewData|null;\n  component: any;\n  context: any;\n  // Attention: Never loop over this, as this will\n  // create a polymorphic usage site.\n  // Instead: Always loop over ViewDefinition.nodes,\n  // and call the right accessor (e.g. `elementData`) based on\n  // the NodeType.\n  nodes: {[key: number]: NodeData};\n  state: ViewState;\n  oldValues: any[];\n  disposables: DisposableFn[]|null;\n  initIndex: number;\n}\n\n/**\n * Bitmask of states\n */\nexport const enum ViewState {\n  BeforeFirstCheck = 1 << 0,\n  FirstCheck = 1 << 1,\n  Attached = 1 << 2,\n  ChecksEnabled = 1 << 3,\n  IsProjectedView = 1 << 4,\n  CheckProjectedView = 1 << 5,\n  CheckProjectedViews = 1 << 6,\n  Destroyed = 1 << 7,\n\n  // InitState Uses 3 bits\n  InitState_Mask = 7 << 8,\n  InitState_BeforeInit = 0 << 8,\n  InitState_CallingOnInit = 1 << 8,\n  InitState_CallingAfterContentInit = 2 << 8,\n  InitState_CallingAfterViewInit = 3 << 8,\n  InitState_AfterInit = 4 << 8,\n\n  CatDetectChanges = Attached | ChecksEnabled,\n  CatInit = BeforeFirstCheck | CatDetectChanges | InitState_BeforeInit\n}\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.\nexport function shiftInitState(\n    view: ViewData, priorInitState: ViewState, newInitState: ViewState): boolean {\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  const state = view.state;\n  const initState = state & ViewState.InitState_Mask;\n  if (initState === priorInitState) {\n    view.state = (state & ~ViewState.InitState_Mask) | newInitState;\n    view.initIndex = -1;\n    return true;\n  }\n  return initState === newInitState;\n}\n\n// Returns true if the lifecycle init method should be called for the node with\n// the given init index.\nexport function shouldCallLifecycleInitHook(\n    view: ViewData, initState: ViewState, index: number): boolean {\n  if ((view.state & ViewState.InitState_Mask) === initState && view.initIndex <= index) {\n    view.initIndex = index + 1;\n    return true;\n  }\n  return false;\n}\n\nexport interface DisposableFn { (): void; }\n\n/**\n * Node instance data.\n *\n * We have a separate type per NodeType to save memory\n * (TextData | ElementData | ProviderData | PureExpressionData | QueryList<any>)\n *\n * To keep our code monomorphic,\n * we prohibit using `NodeData` directly but enforce the use of accessors (`asElementData`, ...).\n * This way, no usage site can get a `NodeData` from view.nodes and then use it for different\n * purposes.\n */\nexport class NodeData { private __brand: any; }\n\n/**\n * Data for an instantiated NodeType.Text.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface TextData { renderText: any; }\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asTextData(view: ViewData, index: number): TextData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Data for an instantiated NodeType.Element.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ElementData {\n  renderElement: any;\n  componentView: ViewData;\n  viewContainer: ViewContainerData|null;\n  template: TemplateData;\n}\n\nexport interface ViewContainerData extends ViewContainerRef {\n  // Note: we are using the prefix _ as ViewContainerData is a ViewContainerRef and therefore\n  // directly\n  // exposed to the user.\n  _embeddedViews: ViewData[];\n}\n\nexport interface TemplateData extends TemplateRef<any> {\n  // views that have been created from the template\n  // of this element,\n  // but inserted into the embeddedViews of another element.\n  // By default, this is undefined.\n  // Note: we are using the prefix _ as TemplateData is a TemplateRef and therefore directly\n  // exposed to the user.\n  _projectedViews: ViewData[];\n}\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asElementData(view: ViewData, index: number): ElementData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Data for an instantiated NodeType.Provider.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ProviderData { instance: any; }\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asProviderData(view: ViewData, index: number): ProviderData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Data for an instantiated NodeType.PureExpression.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface PureExpressionData { value: any; }\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asPureExpressionData(view: ViewData, index: number): PureExpressionData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asQueryList(view: ViewData, index: number): QueryList<any> {\n  return <any>view.nodes[index];\n}\n\nexport interface RootData {\n  injector: Injector;\n  ngModule: NgModuleRef<any>;\n  projectableNodes: any[][];\n  selectorOrNode: any;\n  renderer: Renderer2;\n  rendererFactory: RendererFactory2;\n  errorHandler: ErrorHandler;\n  sanitizer: Sanitizer;\n}\n\nexport abstract class DebugContext {\n  abstract get view(): ViewData;\n  abstract get nodeIndex(): number|null;\n  abstract get injector(): Injector;\n  abstract get component(): any;\n  abstract get providerTokens(): any[];\n  abstract get references(): {[key: string]: any};\n  abstract get context(): any;\n  abstract get componentRenderElement(): any;\n  abstract get renderNode(): any;\n  abstract logError(console: Console, ...values: any[]): void;\n}\n\n// -------------------------------------\n// Other\n// -------------------------------------\n\nexport const enum CheckType {CheckAndUpdate, CheckNoChanges}\n\nexport interface ProviderOverride {\n  token: any;\n  flags: NodeFlags;\n  value: any;\n  deps: ([DepFlags, any]|any)[];\n  deprecatedBehavior: boolean;\n}\n\nexport interface Services {\n  setCurrentNode(view: ViewData, nodeIndex: number): void;\n  createRootView(\n      injector: Injector, projectableNodes: any[][], rootSelectorOrNode: string|any,\n      def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData;\n  createEmbeddedView(parent: ViewData, anchorDef: NodeDef, viewDef: ViewDefinition, context?: any):\n      ViewData;\n  createComponentView(\n      parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData;\n  createNgModuleRef(\n      moduleType: Type<any>, parent: Injector, bootstrapComponents: Type<any>[],\n      def: NgModuleDefinition): NgModuleRef<any>;\n  overrideProvider(override: ProviderOverride): void;\n  overrideComponentView(compType: Type<any>, compFactory: ComponentFactory<any>): void;\n  clearOverrides(): void;\n  checkAndUpdateView(view: ViewData): void;\n  checkNoChangesView(view: ViewData): void;\n  destroyView(view: ViewData): void;\n  resolveDep(\n      view: ViewData, elDef: NodeDef|null, allowPrivateServices: boolean, depDef: DepDef,\n      notFoundValue?: any): any;\n  createDebugContext(view: ViewData, nodeIndex: number): DebugContext;\n  handleEvent: ViewHandleEventFn;\n  updateDirectives: (view: ViewData, checkType: CheckType) => void;\n  updateRenderer: (view: ViewData, checkType: CheckType) => void;\n  dirtyParentQueries: (view: ViewData) => void;\n}\n\n/**\n * This object is used to prevent cycles in the source files and to have a place where\n * debug mode can hook it. It is lazily filled when `isDevMode` is known.\n */\nexport const Services: Services = {\n  setCurrentNode: undefined !,\n  createRootView: undefined !,\n  createEmbeddedView: undefined !,\n  createComponentView: undefined !,\n  createNgModuleRef: undefined !,\n  overrideProvider: undefined !,\n  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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"../../","sources":["packages/core/src/view/types.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector} from '../di';\nimport {ErrorHandler} from '../error_handler';\nimport {ComponentFactory} from '../linker/component_factory';\nimport {NgModuleRef} from '../linker/ng_module_factory';\nimport {QueryList} from '../linker/query_list';\nimport {TemplateRef} from '../linker/template_ref';\nimport {ViewContainerRef} from '../linker/view_container_ref';\nimport {Renderer2, RendererFactory2, RendererType2} from '../render/api';\nimport {Sanitizer, SecurityContext} from '../sanitization/security';\nimport {Type} from '../type';\n\n\n// -------------------------------------\n// Defs\n// -------------------------------------\n\n/**\n * Factory for ViewDefinitions/NgModuleDefinitions.\n * We use a function so we can reexeute it in case an error happens and use the given logger\n * function to log the error from the definition of the node, which is shown in all browser\n * logs.\n */\nexport interface DefinitionFactory<D extends Definition<any>> { (logger: NodeLogger): D; }\n\n/**\n * Function to call console.error at the right source location. This is an indirection\n * via another function as browser will log the location that actually called\n * `console.error`.\n */\nexport interface NodeLogger { (): () => void; }\n\nexport interface Definition<DF extends DefinitionFactory<any>> { factory: DF|null; }\n\nexport interface NgModuleDefinition extends Definition<NgModuleDefinitionFactory> {\n  providers: NgModuleProviderDef[];\n  providersByKey: {[tokenKey: string]: NgModuleProviderDef};\n  modules: any[];\n  isRoot: boolean;\n}\n\nexport interface NgModuleDefinitionFactory extends DefinitionFactory<NgModuleDefinition> {}\n\nexport interface ViewDefinition extends Definition<ViewDefinitionFactory> {\n  flags: ViewFlags;\n  updateDirectives: ViewUpdateFn;\n  updateRenderer: ViewUpdateFn;\n  handleEvent: ViewHandleEventFn;\n  /**\n   * Order: Depth first.\n   * Especially providers are before elements / anchors.\n   */\n  nodes: NodeDef[];\n  /** aggregated NodeFlags for all nodes **/\n  nodeFlags: NodeFlags;\n  rootNodeFlags: NodeFlags;\n  lastRenderRootNode: NodeDef|null;\n  bindingCount: number;\n  outputCount: number;\n  /**\n   * Binary or of all query ids that are matched by one of the nodes.\n   * This includes query ids from templates as well.\n   * Used as a bloom filter.\n   */\n  nodeMatchedQueries: number;\n}\n\nexport interface ViewDefinitionFactory extends DefinitionFactory<ViewDefinition> {}\n\n\nexport interface ViewUpdateFn { (check: NodeCheckFn, view: ViewData): void; }\n\n// helper functions to create an overloaded function type.\nexport interface NodeCheckFn {\n  (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Dynamic, values: any[]): any;\n\n  (view: ViewData, nodeIndex: number, argStyle: ArgumentType.Inline, v0?: any, v1?: any, v2?: any,\n   v3?: any, v4?: any, v5?: any, v6?: any, v7?: any, v8?: any, v9?: any): any;\n}\n\nexport const enum ArgumentType {Inline = 0, Dynamic = 1}\n\nexport interface ViewHandleEventFn {\n  (view: ViewData, nodeIndex: number, eventName: string, event: any): boolean;\n}\n\n/**\n * Bitmask for ViewDefinition.flags.\n */\nexport const enum ViewFlags {\n  None = 0,\n  OnPush = 1 << 1,\n}\n\n/**\n * A node definition in the view.\n *\n * Note: We use one type for all nodes so that loops that loop over all nodes\n * of a ViewDefinition stay monomorphic!\n */\nexport interface NodeDef {\n  flags: NodeFlags;\n  // Index of the node in view data and view definition (those are the same)\n  nodeIndex: number;\n  // Index of the node in the check functions\n  // Differ from nodeIndex when nodes are added or removed at runtime (ie after compilation)\n  checkIndex: number;\n  parent: NodeDef|null;\n  renderParent: NodeDef|null;\n  /** this is checked against NgContentDef.index to find matched nodes */\n  ngContentIndex: number|null;\n  /** number of transitive children */\n  childCount: number;\n  /** aggregated NodeFlags for all transitive children (does not include self) **/\n  childFlags: NodeFlags;\n  /** aggregated NodeFlags for all direct children (does not include self) **/\n  directChildFlags: NodeFlags;\n\n  bindingIndex: number;\n  bindings: BindingDef[];\n  bindingFlags: BindingFlags;\n  outputIndex: number;\n  outputs: OutputDef[];\n  /**\n   * references that the user placed on the element\n   */\n  references: {[refId: string]: QueryValueType};\n  /**\n   * ids and value types of all queries that are matched by this node.\n   */\n  matchedQueries: {[queryId: number]: QueryValueType};\n  /** Binary or of all matched query ids of this node. */\n  matchedQueryIds: number;\n  /**\n   * Binary or of all query ids that are matched by one of the children.\n   * This includes query ids from templates as well.\n   * Used as a bloom filter.\n   */\n  childMatchedQueries: number;\n  element: ElementDef|null;\n  provider: ProviderDef|null;\n  text: TextDef|null;\n  query: QueryDef|null;\n  ngContent: NgContentDef|null;\n}\n\n/**\n * Bitmask for NodeDef.flags.\n * Naming convention:\n * - `Type...`: flags that are mutually exclusive\n * - `Cat...`: union of multiple `Type...` (short for category).\n */\nexport const enum NodeFlags {\n  None = 0,\n  TypeElement = 1 << 0,\n  TypeText = 1 << 1,\n  ProjectedTemplate = 1 << 2,\n  CatRenderNode = TypeElement | TypeText,\n  TypeNgContent = 1 << 3,\n  TypePipe = 1 << 4,\n  TypePureArray = 1 << 5,\n  TypePureObject = 1 << 6,\n  TypePurePipe = 1 << 7,\n  CatPureExpression = TypePureArray | TypePureObject | TypePurePipe,\n  TypeValueProvider = 1 << 8,\n  TypeClassProvider = 1 << 9,\n  TypeFactoryProvider = 1 << 10,\n  TypeUseExistingProvider = 1 << 11,\n  LazyProvider = 1 << 12,\n  PrivateProvider = 1 << 13,\n  TypeDirective = 1 << 14,\n  Component = 1 << 15,\n  CatProviderNoDirective =\n      TypeValueProvider | TypeClassProvider | TypeFactoryProvider | TypeUseExistingProvider,\n  CatProvider = CatProviderNoDirective | TypeDirective,\n  OnInit = 1 << 16,\n  OnDestroy = 1 << 17,\n  DoCheck = 1 << 18,\n  OnChanges = 1 << 19,\n  AfterContentInit = 1 << 20,\n  AfterContentChecked = 1 << 21,\n  AfterViewInit = 1 << 22,\n  AfterViewChecked = 1 << 23,\n  EmbeddedViews = 1 << 24,\n  ComponentView = 1 << 25,\n  TypeContentQuery = 1 << 26,\n  TypeViewQuery = 1 << 27,\n  StaticQuery = 1 << 28,\n  DynamicQuery = 1 << 29,\n  TypeNgModule = 1 << 30,\n  CatQuery = TypeContentQuery | TypeViewQuery,\n\n  // mutually exclusive values...\n  Types = CatRenderNode | TypeNgContent | TypePipe | CatPureExpression | CatProvider | CatQuery\n}\n\nexport interface BindingDef {\n  flags: BindingFlags;\n  ns: string|null;\n  name: string|null;\n  nonMinifiedName: string|null;\n  securityContext: SecurityContext|null;\n  suffix: string|null;\n}\n\nexport const enum BindingFlags {\n  TypeElementAttribute = 1 << 0,\n  TypeElementClass = 1 << 1,\n  TypeElementStyle = 1 << 2,\n  TypeProperty = 1 << 3,\n  SyntheticProperty = 1 << 4,\n  SyntheticHostProperty = 1 << 5,\n  CatSyntheticProperty = SyntheticProperty | SyntheticHostProperty,\n\n  // mutually exclusive values...\n  Types = TypeElementAttribute | TypeElementClass | TypeElementStyle | TypeProperty\n}\n\nexport interface OutputDef {\n  type: OutputType;\n  target: 'window'|'document'|'body'|'component'|null;\n  eventName: string;\n  propName: string|null;\n}\n\nexport const enum OutputType {ElementOutput, DirectiveOutput}\n\nexport const enum QueryValueType {\n  ElementRef = 0,\n  RenderElement = 1,\n  TemplateRef = 2,\n  ViewContainerRef = 3,\n  Provider = 4\n}\n\nexport interface ElementDef {\n  // set to null for `<ng-container>`\n  name: string|null;\n  ns: string|null;\n  /** ns, name, value */\n  attrs: [string, string, string][]|null;\n  template: ViewDefinition|null;\n  componentProvider: NodeDef|null;\n  componentRendererType: RendererType2|null;\n  // closure to allow recursive components\n  componentView: ViewDefinitionFactory|null;\n  /**\n   * visible public providers for DI in the view,\n   * as see from this element. This does not include private providers.\n   */\n  publicProviders: {[tokenKey: string]: NodeDef}|null;\n  /**\n   * same as visiblePublicProviders, but also includes private providers\n   * that are located on this element.\n   */\n  allProviders: {[tokenKey: string]: NodeDef}|null;\n  handleEvent: ElementHandleEventFn|null;\n}\n\nexport interface ElementHandleEventFn { (view: ViewData, eventName: string, event: any): boolean; }\n\nexport interface ProviderDef {\n  token: any;\n  value: any;\n  deps: DepDef[];\n}\n\nexport interface NgModuleProviderDef {\n  flags: NodeFlags;\n  index: number;\n  token: any;\n  value: any;\n  deps: DepDef[];\n}\n\nexport interface DepDef {\n  flags: DepFlags;\n  token: any;\n  tokenKey: string;\n}\n\n/**\n * Bitmask for DI flags\n */\nexport const enum DepFlags {\n  None = 0,\n  SkipSelf = 1 << 0,\n  Optional = 1 << 1,\n  Self = 1 << 2,\n  Value = 1 << 3,\n}\n\nexport interface TextDef { prefix: string; }\n\nexport interface QueryDef {\n  id: number;\n  // variant of the id that can be used to check against NodeDef.matchedQueryIds, ...\n  filterId: number;\n  bindings: QueryBindingDef[];\n}\n\nexport interface QueryBindingDef {\n  propName: string;\n  bindingType: QueryBindingType;\n}\n\nexport const enum QueryBindingType {First = 0, All = 1}\n\nexport interface NgContentDef {\n  /**\n   * this index is checked against NodeDef.ngContentIndex to find the nodes\n   * that are matched by this ng-content.\n   * Note that a NodeDef with an ng-content can be reprojected, i.e.\n   * have a ngContentIndex on its own.\n   */\n  index: number;\n}\n\n// -------------------------------------\n// Data\n// -------------------------------------\n\nexport interface NgModuleData extends Injector, NgModuleRef<any> {\n  // Note: we are using the prefix _ as NgModuleData is an NgModuleRef and therefore directly\n  // exposed to the user.\n  _def: NgModuleDefinition;\n  _parent: Injector;\n  _providers: any[];\n}\n\n/**\n * View instance data.\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ViewData {\n  def: ViewDefinition;\n  root: RootData;\n  renderer: Renderer2;\n  // index of component provider / anchor.\n  parentNodeDef: NodeDef|null;\n  parent: ViewData|null;\n  viewContainerParent: ViewData|null;\n  component: any;\n  context: any;\n  // Attention: Never loop over this, as this will\n  // create a polymorphic usage site.\n  // Instead: Always loop over ViewDefinition.nodes,\n  // and call the right accessor (e.g. `elementData`) based on\n  // the NodeType.\n  nodes: {[key: number]: NodeData};\n  state: ViewState;\n  oldValues: any[];\n  disposables: DisposableFn[]|null;\n  initIndex: number;\n}\n\n/**\n * Bitmask of states\n */\nexport const enum ViewState {\n  BeforeFirstCheck = 1 << 0,\n  FirstCheck = 1 << 1,\n  Attached = 1 << 2,\n  ChecksEnabled = 1 << 3,\n  IsProjectedView = 1 << 4,\n  CheckProjectedView = 1 << 5,\n  CheckProjectedViews = 1 << 6,\n  Destroyed = 1 << 7,\n\n  // InitState Uses 3 bits\n  InitState_Mask = 7 << 8,\n  InitState_BeforeInit = 0 << 8,\n  InitState_CallingOnInit = 1 << 8,\n  InitState_CallingAfterContentInit = 2 << 8,\n  InitState_CallingAfterViewInit = 3 << 8,\n  InitState_AfterInit = 4 << 8,\n\n  CatDetectChanges = Attached | ChecksEnabled,\n  CatInit = BeforeFirstCheck | CatDetectChanges | InitState_BeforeInit\n}\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.\nexport function shiftInitState(\n    view: ViewData, priorInitState: ViewState, newInitState: ViewState): boolean {\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  const state = view.state;\n  const initState = state & ViewState.InitState_Mask;\n  if (initState === priorInitState) {\n    view.state = (state & ~ViewState.InitState_Mask) | newInitState;\n    view.initIndex = -1;\n    return true;\n  }\n  return initState === newInitState;\n}\n\n// Returns true if the lifecycle init method should be called for the node with\n// the given init index.\nexport function shouldCallLifecycleInitHook(\n    view: ViewData, initState: ViewState, index: number): boolean {\n  if ((view.state & ViewState.InitState_Mask) === initState && view.initIndex <= index) {\n    view.initIndex = index + 1;\n    return true;\n  }\n  return false;\n}\n\nexport interface DisposableFn { (): void; }\n\n/**\n * Node instance data.\n *\n * We have a separate type per NodeType to save memory\n * (TextData | ElementData | ProviderData | PureExpressionData | QueryList<any>)\n *\n * To keep our code monomorphic,\n * we prohibit using `NodeData` directly but enforce the use of accessors (`asElementData`, ...).\n * This way, no usage site can get a `NodeData` from view.nodes and then use it for different\n * purposes.\n */\nexport class NodeData { private __brand: any; }\n\n/**\n * Data for an instantiated NodeType.Text.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface TextData { renderText: any; }\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asTextData(view: ViewData, index: number): TextData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Data for an instantiated NodeType.Element.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ElementData {\n  renderElement: any;\n  componentView: ViewData;\n  viewContainer: ViewContainerData|null;\n  template: TemplateData;\n}\n\nexport interface ViewContainerData extends ViewContainerRef {\n  // Note: we are using the prefix _ as ViewContainerData is a ViewContainerRef and therefore\n  // directly\n  // exposed to the user.\n  _embeddedViews: ViewData[];\n}\n\nexport interface TemplateData extends TemplateRef<any> {\n  // views that have been created from the template\n  // of this element,\n  // but inserted into the embeddedViews of another element.\n  // By default, this is undefined.\n  // Note: we are using the prefix _ as TemplateData is a TemplateRef and therefore directly\n  // exposed to the user.\n  _projectedViews: ViewData[];\n}\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asElementData(view: ViewData, index: number): ElementData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Data for an instantiated NodeType.Provider.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface ProviderData { instance: any; }\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asProviderData(view: ViewData, index: number): ProviderData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Data for an instantiated NodeType.PureExpression.\n *\n * Attention: Adding fields to this is performance sensitive!\n */\nexport interface PureExpressionData { value: any; }\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asPureExpressionData(view: ViewData, index: number): PureExpressionData {\n  return <any>view.nodes[index];\n}\n\n/**\n * Accessor for view.nodes, enforcing that every usage site stays monomorphic.\n */\nexport function asQueryList(view: ViewData, index: number): QueryList<any> {\n  return <any>view.nodes[index];\n}\n\nexport interface RootData {\n  injector: Injector;\n  ngModule: NgModuleRef<any>;\n  projectableNodes: any[][];\n  selectorOrNode: any;\n  renderer: Renderer2;\n  rendererFactory: RendererFactory2;\n  errorHandler: ErrorHandler;\n  sanitizer: Sanitizer;\n}\n\nexport abstract class DebugContext {\n  abstract get view(): ViewData;\n  abstract get nodeIndex(): number|null;\n  abstract get injector(): Injector;\n  abstract get component(): any;\n  abstract get providerTokens(): any[];\n  abstract get references(): {[key: string]: any};\n  abstract get context(): any;\n  abstract get componentRenderElement(): any;\n  abstract get renderNode(): any;\n  abstract logError(console: Console, ...values: any[]): void;\n}\n\n// -------------------------------------\n// Other\n// -------------------------------------\n\nexport const enum CheckType {CheckAndUpdate, CheckNoChanges}\n\nexport interface ProviderOverride {\n  token: any;\n  flags: NodeFlags;\n  value: any;\n  deps: ([DepFlags, any]|any)[];\n  deprecatedBehavior: boolean;\n}\n\nexport interface Services {\n  setCurrentNode(view: ViewData, nodeIndex: number): void;\n  createRootView(\n      injector: Injector, projectableNodes: any[][], rootSelectorOrNode: string|any,\n      def: ViewDefinition, ngModule: NgModuleRef<any>, context?: any): ViewData;\n  createEmbeddedView(parent: ViewData, anchorDef: NodeDef, viewDef: ViewDefinition, context?: any):\n      ViewData;\n  createComponentView(\n      parentView: ViewData, nodeDef: NodeDef, viewDef: ViewDefinition, hostElement: any): ViewData;\n  createNgModuleRef(\n      moduleType: Type<any>, parent: Injector, bootstrapComponents: Type<any>[],\n      def: NgModuleDefinition): NgModuleRef<any>;\n  overrideProvider(override: ProviderOverride): void;\n  overrideComponentView(compType: Type<any>, compFactory: ComponentFactory<any>): void;\n  clearOverrides(): void;\n  checkAndUpdateView(view: ViewData): void;\n  checkNoChangesView(view: ViewData): void;\n  destroyView(view: ViewData): void;\n  resolveDep(\n      view: ViewData, elDef: NodeDef|null, allowPrivateServices: boolean, depDef: DepDef,\n      notFoundValue?: any): any;\n  createDebugContext(view: ViewData, nodeIndex: number): DebugContext;\n  handleEvent: ViewHandleEventFn;\n  updateDirectives: (view: ViewData, checkType: CheckType) => void;\n  updateRenderer: (view: ViewData, checkType: CheckType) => void;\n  dirtyParentQueries: (view: ViewData) => void;\n}\n\n/**\n * This object is used to prevent cycles in the source files and to have a place where\n * debug mode can hook it. It is lazily filled when `isDevMode` is known.\n */\nexport const Services: Services = {\n  setCurrentNode: undefined !,\n  createRootView: undefined !,\n  createEmbeddedView: undefined !,\n  createComponentView: undefined !,\n  createNgModuleRef: undefined !,\n  overrideProvider: undefined !,\n  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"]}