@angular/core 8.0.3 → 8.1.0-beta.0

package/esm2015/src/render3/interfaces/node.js

@@ -2,13 +2,6 @@
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * 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
- */
 /** @enum {number} */
 const TNodeType = {
     /**
@@ -160,6 +153,21 @@ const AttributeMarker = {
      * ```
      */
     ProjectAs: 5,
+    /**
+     * Signals that the following attribute will be translated by runtime i18n
+     *
+     * For example, given the following HTML:
+     *
+     * ```
+     * <div moo="car" foo="value" i18n-foo [bar]="binding" i18n-bar>
+     * ```
+     *
+     * the generated code is:
+     *
+     * ```
+     * var _c1 = ['moo', 'car', AttributeMarker.I18n, 'foo', 'bar'];
+     */
+    I18n: 6,
 };
 export { AttributeMarker };
 /**
@@ -418,6 +426,10 @@ if (false) {
      * @type {?}
      */
     TNode.prototype.onElementCreationFns;
+    /** @type {?} */
+    TNode.prototype.newStyles;
+    /** @type {?} */
+    TNode.prototype.newClasses;
 }
 /**
  * Static data for an element
@@ -599,4 +611,4 @@ if (false) {
 // failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/node.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAkBE;;OAEG;IACH,YAAa;IACb;;OAEG;IACH,aAAc;IACd;;OAEG;IACH,OAAQ;IACR;;OAEG;IACH,UAAW;IACX;;OAEG;IACH,mBAAoB;IACpB;;OAEG;IACH,eAAgB;;;;;IAOhB,iDAAiD;IACjD,cAAqB;IAErB,qDAAqD;IACrD,cAAqB;IAErB,wEAAwE;IACxE,kBAAyB;IAEzB,yDAAyD;IACzD,gBAAuB;IAEvB,yDAAyD;IACzD,iBAAuB;;;;;IAOvB,4FAA4F;IAC5F,8BAA4D;IAE5D;0BACsB;IACtB,8BAA+B;IAC/B,mCAAiE;;;;;IAOjE;;;;OAIG;IACH,eAAgB;IAEhB;;;;;;;;;;;;;;;QAeI;IACJ,UAAW;IAEX;;;;;;;;;;;;;;;;OAgBG;IACH,SAAU;IAEV;;;;;;;;;;;;;;OAcG;IACH,WAAY;IAEZ;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,WAAY;IAEZ;;;;;;;;;;;;;;OAcG;IACH,YAAa;;;;;;;;;;;;;;;AAsBf,2BA4OC;;;;;;IA1OC,qBAAgB;;;;;;;;;;IAUhB,sBAAc;;;;;;;;;;;;;;;IAed,8BAAsB;;;;;IAKtB,+BAAuB;;;;;IAKvB,6BAAqB;;;;;;IAMrB,2CAAmC;;;;;;IAMnC,yCAAiC;;;;;IAKjC,sBAAkB;;;;;;;;IASlB,gCAAsC;;;;;IAGtC,wBAAqB;;;;;;;;;;;;;;;;IAgBrB,sBAAwB;;;;;;;;;;;;;;;;;;;IAmBxB,2BAAmC;;;;;IAGnC,8BAA+C;;;;;;;;IAQ/C,uBAAuC;;;;;;;;IAQvC,wBAAwC;;;;;;;;;;;;;;;;;;;;;;IAsBxC,uBAA2B;;;;;;IAM3B,qBAAiB;;;;;;;;IAQjB,+BAA2B;;;;;;;;IAQ3B,sBAAkB;;;;;;;;;;;;;;;;IAgBlB,uBAAyC;;IAEzC,gCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwCrC,2BAA0C;;;;;;;;;;;;;IAa1C,qCAAsC;;;;;;AAIxC,kCAkBC;;;;;;IAhBC,6BAAc;;IACd,6BAAwF;;;;;;;IAMxF,8BAAgD;;IAChD,8BAAa;;;;;;;IAOb,kCAAmC;;;;;;AAIrC,+BAYC;;;;;;IAVC,0BAAc;;IACd,0BAAY;;;;;;;IAMZ,2BAAgD;;IAChD,2BAAa;;IACb,+BAAiB;;;;;;AAInB,oCAmBC;;;;;;;;;IAZC,+BAAc;;IACd,+BAAY;;;;;;;;IAQZ,gCAAgD;;IAChD,gCAA2B;;IAC3B,oCAAiB;;;;;;AAInB,2CAOC;;;;;;IALC,sCAAc;;IACd,sCAAwF;;IACxF,uCAAgD;;IAChD,uCAAa;;IACb,2CAAiB;;;;;;AAInB,uCAYC;;;;;;IAVC,kCAAc;;IACd,kCAAmC;;IACnC,mCAAgD;;IAChD,mCAAa;;IACb,uCAAiB;;;;;;IAKjB,4CAA6B;;;;;;AAI/B,+BAOC;;;;;;IALC,0BAAc;;IACd,0BAAwF;;IACxF,2BAA4B;;IAC5B,2BAAa;;IACb,+BAAiB;;;;;;AAInB,qCAaC;;;;;;IAXC,gCAAY;;;;;;;IAMZ,iCAAgD;;IAChD,iCAAa;;;;;IAGb,qCAAmB;;;;;AA+DrB,MAAM,OAAO,6BAA6B,GAAG,CAAC","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 {CssSelector} from './projection';\nimport {RNode} from './renderer';\nimport {StylingContext} from './styling';\nimport {LView, TView} from './view';\n\n\n/**\n * TNodeType corresponds to the {@link TNode} `type` property.\n */\nexport const enum TNodeType {\n  /**\n   * The TNode contains information about an {@link LContainer} for embedded views.\n   */\n  Container = 0,\n  /**\n   * The TNode contains information about an `<ng-content>` projection\n   */\n  Projection = 1,\n  /**\n   * The TNode contains information about an {@link LView}\n   */\n  View = 2,\n  /**\n   * The TNode contains information about a DOM element aka {@link RNode}.\n   */\n  Element = 3,\n  /**\n   * The TNode contains information about an `<ng-container>` element {@link RNode}.\n   */\n  ElementContainer = 4,\n  /**\n   * The TNode contains information about an ICU comment used in `i18n`.\n   */\n  IcuContainer = 5,\n}\n\n/**\n * Corresponds to the TNode.flags property.\n */\nexport const enum TNodeFlags {\n  /** This bit is set if the node is a component */\n  isComponent = 0b00001,\n\n  /** This bit is set if the node has been projected */\n  isProjected = 0b00010,\n\n  /** This bit is set if any directive on this node has content queries */\n  hasContentQuery = 0b00100,\n\n  /** This bit is set if the node has any \"class\" inputs */\n  hasClassInput = 0b01000,\n\n  /** This bit is set if the node has any \"style\" inputs */\n  hasStyleInput = 0b10000,\n}\n\n/**\n * Corresponds to the TNode.providerIndexes property.\n */\nexport const enum TNodeProviderIndexes {\n  /** The index of the first provider on this node is encoded on the least significant bits */\n  ProvidersStartIndexMask = 0b00000000000000001111111111111111,\n\n  /** The count of view providers from the component on this node is encoded on the 16 most\n     significant bits */\n  CptViewProvidersCountShift = 16,\n  CptViewProvidersCountShifter = 0b00000000000000010000000000000000,\n}\n/**\n * A set of marker values to be used in the attributes arrays. These markers indicate that some\n * items are not regular attributes and the processing should be adapted accordingly.\n */\nexport const enum AttributeMarker {\n  /**\n   * Marker indicates that the following 3 values in the attributes array are:\n   * namespaceUri, attributeName, attributeValue\n   * in that order.\n   */\n  NamespaceURI = 0,\n\n  /**\n    * Signals class declaration.\n    *\n    * Each value following `Classes` designates a class name to include on the element.\n    * ## Example:\n    *\n    * Given:\n    * ```\n    * <div class=\"foo bar baz\">...<d/vi>\n    * ```\n    *\n    * the generated code is:\n    * ```\n    * var _c1 = [AttributeMarker.Classes, 'foo', 'bar', 'baz'];\n    * ```\n    */\n  Classes = 1,\n\n  /**\n   * Signals style declaration.\n   *\n   * Each pair of values following `Styles` designates a style name and value to include on the\n   * element.\n   * ## Example:\n   *\n   * Given:\n   * ```\n   * <div style=\"width:100px; height:200px; color:red\">...</div>\n   * ```\n   *\n   * the generated code is:\n   * ```\n   * var _c1 = [AttributeMarker.Styles, 'width', '100px', 'height'. '200px', 'color', 'red'];\n   * ```\n   */\n  Styles = 2,\n\n  /**\n   * Signals that the following attribute names were extracted from input or output bindings.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div moo=\"car\" [foo]=\"exp\" (bar)=\"doSth()\">\n   * ```\n   *\n   * the generated code is:\n   *\n   * ```\n   * var _c1 = ['moo', 'car', AttributeMarker.Bindings, 'foo', 'bar'];\n   * ```\n   */\n  Bindings = 3,\n\n  /**\n   * Signals that the following attribute names were hoisted from an inline-template declaration.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div *ngFor=\"let value of values; trackBy:trackBy\" dirA [dirB]=\"value\">\n   * ```\n   *\n   * the generated code for the `template()` instruction would include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB', AttributeMarker.Template, 'ngFor', 'ngForOf',\n   * 'ngForTrackBy', 'let-value']\n   * ```\n   *\n   * while the generated code for the `element()` instruction inside the template function would\n   * include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB']\n   * ```\n   */\n  Template = 4,\n\n  /**\n   * Signals that the following attribute is `ngProjectAs` and its value is a parsed `CssSelector`.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <h1 attr=\"value\" ngProjectAs=\"[title]\">\n   * ```\n   *\n   * the generated code for the `element()` instruction would include:\n   *\n   * ```\n   * ['attr', 'value', AttributeMarker.ProjectAs, ['', 'title', '']]\n   * ```\n   */\n  ProjectAs = 5\n}\n\n/**\n * A combination of:\n * - Attribute names and values.\n * - Special markers acting as flags to alter attributes processing.\n * - Parsed ngProjectAs selectors.\n */\nexport type TAttributes = (string | AttributeMarker | CssSelector)[];\n\n/**\n * Binding data (flyweight) for a particular node that is shared between all templates\n * of a specific type.\n *\n * If a property is:\n *    - PropertyAliases: that property's data was generated and this is it\n *    - Null: that property's data was already generated and nothing was found.\n *    - Undefined: that property's data has not yet been generated\n *\n * see: https://en.wikipedia.org/wiki/Flyweight_pattern for more on the Flyweight pattern\n */\nexport interface TNode {\n  /** The type of the TNode. See TNodeType. */\n  type: TNodeType;\n\n  /**\n   * Index of the TNode in TView.data and corresponding native element in LView.\n   *\n   * This is necessary to get from any TNode to its corresponding native element when\n   * traversing the node tree.\n   *\n   * If index is -1, this is a dynamically created container node or embedded view node.\n   */\n  index: number;\n\n  /**\n   * The index of the closest injector in this node's LView.\n   *\n   * If the index === -1, there is no injector on this node or any ancestor node in this view.\n   *\n   * If the index !== -1, it is the index of this node's injector OR the index of a parent injector\n   * in the same view. We pass the parent injector index down the node tree of a view so it's\n   * possible to find the parent injector without walking a potentially deep node tree. Injector\n   * indices are not set across view boundaries because there could be multiple component hosts.\n   *\n   * If tNode.injectorIndex === tNode.parent.injectorIndex, then the index belongs to a parent\n   * injector.\n   */\n  injectorIndex: number;\n\n  /**\n   * Stores starting index of the directives.\n   */\n  directiveStart: number;\n\n  /**\n   * Stores final exclusive index of the directives.\n   */\n  directiveEnd: number;\n\n  /**\n   * Stores the first index where property binding metadata is stored for\n   * this node.\n   */\n  propertyMetadataStartIndex: number;\n\n  /**\n   * Stores the exclusive final index where property binding metadata is\n   * stored for this node.\n   */\n  propertyMetadataEndIndex: number;\n\n  /**\n   * Stores if Node isComponent, isProjected, hasContentQuery, hasClassInput and hasStyleInput\n   */\n  flags: TNodeFlags;\n\n  /**\n   * This number stores two values using its bits:\n   *\n   * - the index of the first provider on that node (first 16 bits)\n   * - the count of view providers from the component on this node (last 16 bits)\n   */\n  // TODO(misko): break this into actual vars.\n  providerIndexes: TNodeProviderIndexes;\n\n  /** The tag name associated with this node. */\n  tagName: string|null;\n\n  /**\n   * Attributes associated with an element. We need to store attributes to support various use-cases\n   * (attribute injection, content projection with selectors, directives matching).\n   * Attributes are stored statically because reading them from the DOM would be way too slow for\n   * content projection and queries.\n   *\n   * Since attrs will always be calculated first, they will never need to be marked undefined by\n   * other instructions.\n   *\n   * For regular attributes a name of an attribute and its value alternate in the array.\n   * e.g. ['role', 'checkbox']\n   * This array can contain flags that will indicate \"special attributes\" (attributes with\n   * namespaces, attributes extracted from bindings and outputs).\n   */\n  attrs: TAttributes|null;\n\n  /**\n   * A set of local names under which a given element is exported in a template and\n   * visible to queries. An entry in this array can be created for different reasons:\n   * - an element itself is referenced, ex.: `<div #foo>`\n   * - a component is referenced, ex.: `<my-cmpt #foo>`\n   * - a directive is referenced, ex.: `<my-cmpt #foo=\"directiveExportAs\">`.\n   *\n   * A given element might have different local names and those names can be associated\n   * with a directive. We store local names at even indexes while odd indexes are reserved\n   * for directive index in a view (or `-1` if there is no associated directive).\n   *\n   * Some examples:\n   * - `<div #foo>` => `[\"foo\", -1]`\n   * - `<my-cmpt #foo>` => `[\"foo\", myCmptIdx]`\n   * - `<my-cmpt #foo #bar=\"directiveExportAs\">` => `[\"foo\", myCmptIdx, \"bar\", directiveIdx]`\n   * - `<div #foo #bar=\"directiveExportAs\">` => `[\"foo\", -1, \"bar\", directiveIdx]`\n   */\n  localNames: (string|number)[]|null;\n\n  /** Information about input properties that need to be set once from attribute data. */\n  initialInputs: InitialInputData|null|undefined;\n\n  /**\n   * Input data for all directives on this node.\n   *\n   * - `undefined` means that the prop has not been initialized yet,\n   * - `null` means that the prop has been initialized but no inputs have been found.\n   */\n  inputs: PropertyAliases|null|undefined;\n\n  /**\n   * Output data for all directives on this node.\n   *\n   * - `undefined` means that the prop has not been initialized yet,\n   * - `null` means that the prop has been initialized but no outputs have been found.\n   */\n  outputs: PropertyAliases|null|undefined;\n\n  /**\n   * The TView or TViews attached to this node.\n   *\n   * If this TNode corresponds to an LContainer with inline views, the container will\n   * need to store separate static data for each of its view blocks (TView[]). Otherwise,\n   * nodes in inline views with the same index as nodes in their parent views will overwrite\n   * each other, as they are in the same template.\n   *\n   * Each index in this array corresponds to the static data for a certain\n   * view. So if you had V(0) and V(1) in a container, you might have:\n   *\n   * [\n   *   [{tagName: 'div', attrs: ...}, null],     // V(0) TView\n   *   [{tagName: 'button', attrs ...}, null]    // V(1) TView\n   *\n   * If this TNode corresponds to an LContainer with a template (e.g. structural\n   * directive), the template's TView will be stored here.\n   *\n   * If this TNode corresponds to an element, tViews will be null .\n   */\n  tViews: TView|TView[]|null;\n\n  /**\n   * The next sibling node. Necessary so we can propagate through the root nodes of a view\n   * to insert them or remove them from the DOM.\n   */\n  next: TNode|null;\n\n  /**\n   * The next projected sibling. Since in Angular content projection works on the node-by-node basis\n   * the act of projecting nodes might change nodes relationship at the insertion point (target\n   * view). At the same time we need to keep initial relationship between nodes as expressed in\n   * content view.\n   */\n  projectionNext: TNode|null;\n\n  /**\n   * First child of the current node.\n   *\n   * For component nodes, the child will always be a ContentChild (in same view).\n   * For embedded view nodes, the child will be in their child view.\n   */\n  child: TNode|null;\n\n  /**\n   * Parent node (in the same view only).\n   *\n   * We need a reference to a node's parent so we can append the node to its parent's native\n   * element at the appropriate time.\n   *\n   * If the parent would be in a different view (e.g. component host), this property will be null.\n   * It's important that we don't try to cross component boundaries when retrieving the parent\n   * because the parent will change (e.g. index, attrs) depending on where the component was\n   * used (and thus shouldn't be stored on TNode). In these cases, we retrieve the parent through\n   * LView.node instead (which will be instance-specific).\n   *\n   * If this is an inline view node (V), the parent will be its container.\n   */\n  parent: TElementNode|TContainerNode|null;\n\n  stylingTemplate: StylingContext|null;\n  /**\n   * List of projected TNodes for a given component host element OR index into the said nodes.\n   *\n   * For easier discussion assume this example:\n   * `<parent>`'s view definition:\n   * ```\n   * <child id=\"c1\">content1</child>\n   * <child id=\"c2\"><span>content2</span></child>\n   * ```\n   * `<child>`'s view definition:\n   * ```\n   * <ng-content id=\"cont1\"></ng-content>\n   * ```\n   *\n   * If `Array.isArray(projection)` then `TNode` is a host element:\n   * - `projection` stores the content nodes which are to be projected.\n   *    - The nodes represent categories defined by the selector: For example:\n   *      `<ng-content/><ng-content select=\"abc\"/>` would represent the heads for `<ng-content/>`\n   *      and `<ng-content select=\"abc\"/>` respectively.\n   *    - The nodes we store in `projection` are heads only, we used `.next` to get their\n   *      siblings.\n   *    - The nodes `.next` is sorted/rewritten as part of the projection setup.\n   *    - `projection` size is equal to the number of projections `<ng-content>`. The size of\n   *      `c1` will be `1` because `<child>` has only one `<ng-content>`.\n   * - we store `projection` with the host (`c1`, `c2`) rather than the `<ng-content>` (`cont1`)\n   *   because the same component (`<child>`) can be used in multiple locations (`c1`, `c2`) and as\n   *   a result have different set of nodes to project.\n   * - without `projection` it would be difficult to efficiently traverse nodes to be projected.\n   *\n   * If `typeof projection == 'number'` then `TNode` is a `<ng-content>` element:\n   * - `projection` is an index of the host's `projection`Nodes.\n   *   - This would return the first head node to project:\n   *     `getHost(currentTNode).projection[currentTNode.projection]`.\n   * - When projecting nodes the parent node retrieved may be a `<ng-content>` node, in which case\n   *   the process is recursive in nature (not implementation).\n   *\n   * If `projection` is of type `RNode[][]` than we have a collection of native nodes passed as\n   * projectable nodes during dynamic component creation.\n   */\n  projection: (TNode|RNode[])[]|number|null;\n\n  /**\n   * A buffer of functions that will be called once `elementEnd` (or `element`) completes.\n   *\n   * Due to the nature of how directives work in Angular, some directive code may\n   * need to fire after any template-level code runs. If present, this array will\n   * be flushed (each function will be invoked) once the associated element is\n   * created.\n   *\n   * If an element is created multiple times then this function will be populated\n   * with functions each time the creation block is called.\n   */\n  onElementCreationFns: Function[]|null;\n}\n\n/** Static data for an element  */\nexport interface TElementNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: TElementNode|TTextNode|TElementContainerNode|TContainerNode|TProjectionNode|null;\n  /**\n   * Element nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using viewData[HOST_NODE]).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n\n  /**\n   * If this is a component TNode with projection, this will be an array of projected\n   * TNodes or native nodes (see TNode.projection for more info). If it's a regular element node or\n   * a component without projection, it will be null.\n   */\n  projection: (TNode|RNode[])[]|null;\n}\n\n/** Static data for a text node */\nexport interface TTextNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: null;\n  /**\n   * Text nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n  projection: null;\n}\n\n/** Static data for an LContainer */\nexport interface TContainerNode extends TNode {\n  /**\n   * Index in the data[] array.\n   *\n   * If it's -1, this is a dynamically created container node that isn't stored in\n   * data[] (e.g. when you inject ViewContainerRef) .\n   */\n  index: number;\n  child: null;\n\n  /**\n   * Container nodes will have parents unless:\n   *\n   * - They are the first node of a component or embedded view\n   * - They are dynamically created\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: TView|TView[]|null;\n  projection: null;\n}\n\n/** Static data for an <ng-container> */\nexport interface TElementContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: TElementNode|TTextNode|TContainerNode|TElementContainerNode|TProjectionNode|null;\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n  projection: null;\n}\n\n/** Static data for an ICU expression */\nexport interface TIcuContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: TElementNode|TTextNode|null;\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n  projection: null;\n  /**\n   * Indicates the current active case for an ICU expression.\n   * It is null when there is no active case.\n   */\n  activeCaseIndex: number|null;\n}\n\n/** Static data for a view  */\nexport interface TViewNode extends TNode {\n  /** If -1, it's a dynamically created view. Otherwise, it is the view block ID. */\n  index: number;\n  child: TElementNode|TTextNode|TElementContainerNode|TContainerNode|TProjectionNode|null;\n  parent: TContainerNode|null;\n  tViews: null;\n  projection: null;\n}\n\n/** Static data for an LProjectionNode  */\nexport interface TProjectionNode extends TNode {\n  /** Index in the data[] array */\n  child: null;\n  /**\n   * Projection nodes will have parents unless they are the first node of a component\n   * or embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n\n  /** Index of the projection node. (See TNode.projection for more info.) */\n  projection: number;\n}\n\n/**\n * This mapping is necessary so we can set input properties and output listeners\n * properly at runtime when property names are minified or aliased.\n *\n * Key: unminified / public input or output name\n * Value: array containing minified / internal name and related directive index\n *\n * The value must be an array to support inputs and outputs with the same name\n * on the same node.\n */\nexport type PropertyAliases = {\n  // This uses an object map because using the Map type would be too slow\n  [key: string]: PropertyAliasValue\n};\n\n/**\n * Store the runtime input or output names for all the directives.\n *\n * i+0: directive instance index\n * i+1: publicName\n * i+2: privateName\n *\n * e.g. [0, 'change', 'change-minified']\n */\nexport type PropertyAliasValue = (number | string)[];\n\n/**\n * This array contains information about input properties that\n * need to be set once from attribute data. It's ordered by\n * directive index (relative to element) so it's simple to\n * look up a specific directive's initial input data.\n *\n * Within each sub-array:\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: initial value\n *\n * If a directive on a node does not have any input properties\n * that should be set from attributes, its index is set to null\n * to avoid a sparse array.\n *\n * e.g. [null, ['role-min', 'minified-input', 'button']]\n */\nexport type InitialInputData = (InitialInputs | null)[];\n\n/**\n * Used by InitialInputData to store input properties\n * that should be set once from attributes.\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: initial value\n *\n * e.g. ['role-min', 'minified-input', 'button']\n */\nexport type InitialInputs = string[];\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n\n/**\n * Type representing a set of TNodes that can have local refs (`#foo`) placed on them.\n */\nexport type TNodeWithLocalRefs = TContainerNode | TElementNode | TElementContainerNode;\n\n/**\n * Type for a function that extracts a value for a local refs.\n * Example:\n * - `<div #nativeDivEl>` - `nativeDivEl` should point to the native `<div>` element;\n * - `<ng-template #tplRef>` - `tplRef` should point to the `TemplateRef` instance;\n */\nexport type LocalRefExtractor = (tNode: TNodeWithLocalRefs, currentView: LView) => any;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/node.ts"],"names":[],"mappings":";;;;;;IAkBE;;OAEG;IACH,YAAa;IACb;;OAEG;IACH,aAAc;IACd;;OAEG;IACH,OAAQ;IACR;;OAEG;IACH,UAAW;IACX;;OAEG;IACH,mBAAoB;IACpB;;OAEG;IACH,eAAgB;;;;;IAOhB,iDAAiD;IACjD,cAAqB;IAErB,qDAAqD;IACrD,cAAqB;IAErB,wEAAwE;IACxE,kBAAyB;IAEzB,yDAAyD;IACzD,gBAAuB;IAEvB,yDAAyD;IACzD,iBAAuB;;;;;IAOvB,4FAA4F;IAC5F,8BAA4D;IAE5D;0BACsB;IACtB,8BAA+B;IAC/B,mCAAiE;;;;;IAOjE;;;;OAIG;IACH,eAAgB;IAEhB;;;;;;;;;;;;;;;QAeI;IACJ,UAAW;IAEX;;;;;;;;;;;;;;;;OAgBG;IACH,SAAU;IAEV;;;;;;;;;;;;;;OAcG;IACH,WAAY;IAEZ;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,WAAY;IAEZ;;;;;;;;;;;;;;OAcG;IACH,YAAa;IAEb;;;;;;;;;;;;;OAaG;IACH,OAAI;;;;;;;;;;;;;;;AAsBN,2BAgPC;;;;;;IA9OC,qBAAgB;;;;;;;;;;IAUhB,sBAAc;;;;;;;;;;;;;;;IAed,8BAAsB;;;;;IAKtB,+BAAuB;;;;;IAKvB,6BAAqB;;;;;;IAMrB,2CAAmC;;;;;;IAMnC,yCAAiC;;;;;IAKjC,sBAAkB;;;;;;;;IASlB,gCAAsC;;;;;IAGtC,wBAAqB;;;;;;;;;;;;;;;;IAgBrB,sBAAwB;;;;;;;;;;;;;;;;;;;IAmBxB,2BAAmC;;;;;IAGnC,8BAA+C;;;;;;;;IAQ/C,uBAAuC;;;;;;;;IAQvC,wBAAwC;;;;;;;;;;;;;;;;;;;;;;IAsBxC,uBAA2B;;;;;;IAM3B,qBAAiB;;;;;;;;IAQjB,+BAA2B;;;;;;;;IAQ3B,sBAAkB;;;;;;;;;;;;;;;;IAgBlB,uBAAyC;;IAEzC,gCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwCrC,2BAA0C;;;;;;;;;;;;;IAa1C,qCAAsC;;IAEtC,0BAAgC;;IAEhC,2BAAiC;;;;;;AAInC,kCAkBC;;;;;;IAhBC,6BAAc;;IACd,6BAAwF;;;;;;;IAMxF,8BAAgD;;IAChD,8BAAa;;;;;;;IAOb,kCAAmC;;;;;;AAIrC,+BAYC;;;;;;IAVC,0BAAc;;IACd,0BAAY;;;;;;;IAMZ,2BAAgD;;IAChD,2BAAa;;IACb,+BAAiB;;;;;;AAInB,oCAmBC;;;;;;;;;IAZC,+BAAc;;IACd,+BAAY;;;;;;;;IAQZ,gCAAgD;;IAChD,gCAA2B;;IAC3B,oCAAiB;;;;;;AAInB,2CAOC;;;;;;IALC,sCAAc;;IACd,sCAAwF;;IACxF,uCAAgD;;IAChD,uCAAa;;IACb,2CAAiB;;;;;;AAInB,uCAYC;;;;;;IAVC,kCAAc;;IACd,kCAAmC;;IACnC,mCAAgD;;IAChD,mCAAa;;IACb,uCAAiB;;;;;;IAKjB,4CAA6B;;;;;;AAI/B,+BAOC;;;;;;IALC,0BAAc;;IACd,0BAAwF;;IACxF,2BAA4B;;IAC5B,2BAAa;;IACb,+BAAiB;;;;;;AAInB,qCAaC;;;;;;IAXC,gCAAY;;;;;;;IAMZ,iCAAgD;;IAChD,iCAAa;;;;;IAGb,qCAAmB;;;;;AA+DrB,MAAM,OAAO,6BAA6B,GAAG,CAAC","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 */\nimport {TStylingContext} from '../styling_next/interfaces';\nimport {CssSelector} from './projection';\nimport {RNode} from './renderer';\nimport {StylingContext} from './styling';\nimport {LView, TView} from './view';\n\n\n/**\n * TNodeType corresponds to the {@link TNode} `type` property.\n */\nexport const enum TNodeType {\n  /**\n   * The TNode contains information about an {@link LContainer} for embedded views.\n   */\n  Container = 0,\n  /**\n   * The TNode contains information about an `<ng-content>` projection\n   */\n  Projection = 1,\n  /**\n   * The TNode contains information about an {@link LView}\n   */\n  View = 2,\n  /**\n   * The TNode contains information about a DOM element aka {@link RNode}.\n   */\n  Element = 3,\n  /**\n   * The TNode contains information about an `<ng-container>` element {@link RNode}.\n   */\n  ElementContainer = 4,\n  /**\n   * The TNode contains information about an ICU comment used in `i18n`.\n   */\n  IcuContainer = 5,\n}\n\n/**\n * Corresponds to the TNode.flags property.\n */\nexport const enum TNodeFlags {\n  /** This bit is set if the node is a component */\n  isComponent = 0b00001,\n\n  /** This bit is set if the node has been projected */\n  isProjected = 0b00010,\n\n  /** This bit is set if any directive on this node has content queries */\n  hasContentQuery = 0b00100,\n\n  /** This bit is set if the node has any \"class\" inputs */\n  hasClassInput = 0b01000,\n\n  /** This bit is set if the node has any \"style\" inputs */\n  hasStyleInput = 0b10000,\n}\n\n/**\n * Corresponds to the TNode.providerIndexes property.\n */\nexport const enum TNodeProviderIndexes {\n  /** The index of the first provider on this node is encoded on the least significant bits */\n  ProvidersStartIndexMask = 0b00000000000000001111111111111111,\n\n  /** The count of view providers from the component on this node is encoded on the 16 most\n     significant bits */\n  CptViewProvidersCountShift = 16,\n  CptViewProvidersCountShifter = 0b00000000000000010000000000000000,\n}\n/**\n * A set of marker values to be used in the attributes arrays. These markers indicate that some\n * items are not regular attributes and the processing should be adapted accordingly.\n */\nexport const enum AttributeMarker {\n  /**\n   * Marker indicates that the following 3 values in the attributes array are:\n   * namespaceUri, attributeName, attributeValue\n   * in that order.\n   */\n  NamespaceURI = 0,\n\n  /**\n    * Signals class declaration.\n    *\n    * Each value following `Classes` designates a class name to include on the element.\n    * ## Example:\n    *\n    * Given:\n    * ```\n    * <div class=\"foo bar baz\">...<d/vi>\n    * ```\n    *\n    * the generated code is:\n    * ```\n    * var _c1 = [AttributeMarker.Classes, 'foo', 'bar', 'baz'];\n    * ```\n    */\n  Classes = 1,\n\n  /**\n   * Signals style declaration.\n   *\n   * Each pair of values following `Styles` designates a style name and value to include on the\n   * element.\n   * ## Example:\n   *\n   * Given:\n   * ```\n   * <div style=\"width:100px; height:200px; color:red\">...</div>\n   * ```\n   *\n   * the generated code is:\n   * ```\n   * var _c1 = [AttributeMarker.Styles, 'width', '100px', 'height'. '200px', 'color', 'red'];\n   * ```\n   */\n  Styles = 2,\n\n  /**\n   * Signals that the following attribute names were extracted from input or output bindings.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div moo=\"car\" [foo]=\"exp\" (bar)=\"doSth()\">\n   * ```\n   *\n   * the generated code is:\n   *\n   * ```\n   * var _c1 = ['moo', 'car', AttributeMarker.Bindings, 'foo', 'bar'];\n   * ```\n   */\n  Bindings = 3,\n\n  /**\n   * Signals that the following attribute names were hoisted from an inline-template declaration.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div *ngFor=\"let value of values; trackBy:trackBy\" dirA [dirB]=\"value\">\n   * ```\n   *\n   * the generated code for the `template()` instruction would include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB', AttributeMarker.Template, 'ngFor', 'ngForOf',\n   * 'ngForTrackBy', 'let-value']\n   * ```\n   *\n   * while the generated code for the `element()` instruction inside the template function would\n   * include:\n   *\n   * ```\n   * ['dirA', '', AttributeMarker.Bindings, 'dirB']\n   * ```\n   */\n  Template = 4,\n\n  /**\n   * Signals that the following attribute is `ngProjectAs` and its value is a parsed `CssSelector`.\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <h1 attr=\"value\" ngProjectAs=\"[title]\">\n   * ```\n   *\n   * the generated code for the `element()` instruction would include:\n   *\n   * ```\n   * ['attr', 'value', AttributeMarker.ProjectAs, ['', 'title', '']]\n   * ```\n   */\n  ProjectAs = 5,\n\n  /**\n   * Signals that the following attribute will be translated by runtime i18n\n   *\n   * For example, given the following HTML:\n   *\n   * ```\n   * <div moo=\"car\" foo=\"value\" i18n-foo [bar]=\"binding\" i18n-bar>\n   * ```\n   *\n   * the generated code is:\n   *\n   * ```\n   * var _c1 = ['moo', 'car', AttributeMarker.I18n, 'foo', 'bar'];\n   */\n  I18n,\n}\n\n/**\n * A combination of:\n * - Attribute names and values.\n * - Special markers acting as flags to alter attributes processing.\n * - Parsed ngProjectAs selectors.\n */\nexport type TAttributes = (string | AttributeMarker | CssSelector)[];\n\n/**\n * Binding data (flyweight) for a particular node that is shared between all templates\n * of a specific type.\n *\n * If a property is:\n *    - PropertyAliases: that property's data was generated and this is it\n *    - Null: that property's data was already generated and nothing was found.\n *    - Undefined: that property's data has not yet been generated\n *\n * see: https://en.wikipedia.org/wiki/Flyweight_pattern for more on the Flyweight pattern\n */\nexport interface TNode {\n  /** The type of the TNode. See TNodeType. */\n  type: TNodeType;\n\n  /**\n   * Index of the TNode in TView.data and corresponding native element in LView.\n   *\n   * This is necessary to get from any TNode to its corresponding native element when\n   * traversing the node tree.\n   *\n   * If index is -1, this is a dynamically created container node or embedded view node.\n   */\n  index: number;\n\n  /**\n   * The index of the closest injector in this node's LView.\n   *\n   * If the index === -1, there is no injector on this node or any ancestor node in this view.\n   *\n   * If the index !== -1, it is the index of this node's injector OR the index of a parent injector\n   * in the same view. We pass the parent injector index down the node tree of a view so it's\n   * possible to find the parent injector without walking a potentially deep node tree. Injector\n   * indices are not set across view boundaries because there could be multiple component hosts.\n   *\n   * If tNode.injectorIndex === tNode.parent.injectorIndex, then the index belongs to a parent\n   * injector.\n   */\n  injectorIndex: number;\n\n  /**\n   * Stores starting index of the directives.\n   */\n  directiveStart: number;\n\n  /**\n   * Stores final exclusive index of the directives.\n   */\n  directiveEnd: number;\n\n  /**\n   * Stores the first index where property binding metadata is stored for\n   * this node.\n   */\n  propertyMetadataStartIndex: number;\n\n  /**\n   * Stores the exclusive final index where property binding metadata is\n   * stored for this node.\n   */\n  propertyMetadataEndIndex: number;\n\n  /**\n   * Stores if Node isComponent, isProjected, hasContentQuery, hasClassInput and hasStyleInput\n   */\n  flags: TNodeFlags;\n\n  /**\n   * This number stores two values using its bits:\n   *\n   * - the index of the first provider on that node (first 16 bits)\n   * - the count of view providers from the component on this node (last 16 bits)\n   */\n  // TODO(misko): break this into actual vars.\n  providerIndexes: TNodeProviderIndexes;\n\n  /** The tag name associated with this node. */\n  tagName: string|null;\n\n  /**\n   * Attributes associated with an element. We need to store attributes to support various use-cases\n   * (attribute injection, content projection with selectors, directives matching).\n   * Attributes are stored statically because reading them from the DOM would be way too slow for\n   * content projection and queries.\n   *\n   * Since attrs will always be calculated first, they will never need to be marked undefined by\n   * other instructions.\n   *\n   * For regular attributes a name of an attribute and its value alternate in the array.\n   * e.g. ['role', 'checkbox']\n   * This array can contain flags that will indicate \"special attributes\" (attributes with\n   * namespaces, attributes extracted from bindings and outputs).\n   */\n  attrs: TAttributes|null;\n\n  /**\n   * A set of local names under which a given element is exported in a template and\n   * visible to queries. An entry in this array can be created for different reasons:\n   * - an element itself is referenced, ex.: `<div #foo>`\n   * - a component is referenced, ex.: `<my-cmpt #foo>`\n   * - a directive is referenced, ex.: `<my-cmpt #foo=\"directiveExportAs\">`.\n   *\n   * A given element might have different local names and those names can be associated\n   * with a directive. We store local names at even indexes while odd indexes are reserved\n   * for directive index in a view (or `-1` if there is no associated directive).\n   *\n   * Some examples:\n   * - `<div #foo>` => `[\"foo\", -1]`\n   * - `<my-cmpt #foo>` => `[\"foo\", myCmptIdx]`\n   * - `<my-cmpt #foo #bar=\"directiveExportAs\">` => `[\"foo\", myCmptIdx, \"bar\", directiveIdx]`\n   * - `<div #foo #bar=\"directiveExportAs\">` => `[\"foo\", -1, \"bar\", directiveIdx]`\n   */\n  localNames: (string|number)[]|null;\n\n  /** Information about input properties that need to be set once from attribute data. */\n  initialInputs: InitialInputData|null|undefined;\n\n  /**\n   * Input data for all directives on this node.\n   *\n   * - `undefined` means that the prop has not been initialized yet,\n   * - `null` means that the prop has been initialized but no inputs have been found.\n   */\n  inputs: PropertyAliases|null|undefined;\n\n  /**\n   * Output data for all directives on this node.\n   *\n   * - `undefined` means that the prop has not been initialized yet,\n   * - `null` means that the prop has been initialized but no outputs have been found.\n   */\n  outputs: PropertyAliases|null|undefined;\n\n  /**\n   * The TView or TViews attached to this node.\n   *\n   * If this TNode corresponds to an LContainer with inline views, the container will\n   * need to store separate static data for each of its view blocks (TView[]). Otherwise,\n   * nodes in inline views with the same index as nodes in their parent views will overwrite\n   * each other, as they are in the same template.\n   *\n   * Each index in this array corresponds to the static data for a certain\n   * view. So if you had V(0) and V(1) in a container, you might have:\n   *\n   * [\n   *   [{tagName: 'div', attrs: ...}, null],     // V(0) TView\n   *   [{tagName: 'button', attrs ...}, null]    // V(1) TView\n   *\n   * If this TNode corresponds to an LContainer with a template (e.g. structural\n   * directive), the template's TView will be stored here.\n   *\n   * If this TNode corresponds to an element, tViews will be null .\n   */\n  tViews: TView|TView[]|null;\n\n  /**\n   * The next sibling node. Necessary so we can propagate through the root nodes of a view\n   * to insert them or remove them from the DOM.\n   */\n  next: TNode|null;\n\n  /**\n   * The next projected sibling. Since in Angular content projection works on the node-by-node basis\n   * the act of projecting nodes might change nodes relationship at the insertion point (target\n   * view). At the same time we need to keep initial relationship between nodes as expressed in\n   * content view.\n   */\n  projectionNext: TNode|null;\n\n  /**\n   * First child of the current node.\n   *\n   * For component nodes, the child will always be a ContentChild (in same view).\n   * For embedded view nodes, the child will be in their child view.\n   */\n  child: TNode|null;\n\n  /**\n   * Parent node (in the same view only).\n   *\n   * We need a reference to a node's parent so we can append the node to its parent's native\n   * element at the appropriate time.\n   *\n   * If the parent would be in a different view (e.g. component host), this property will be null.\n   * It's important that we don't try to cross component boundaries when retrieving the parent\n   * because the parent will change (e.g. index, attrs) depending on where the component was\n   * used (and thus shouldn't be stored on TNode). In these cases, we retrieve the parent through\n   * LView.node instead (which will be instance-specific).\n   *\n   * If this is an inline view node (V), the parent will be its container.\n   */\n  parent: TElementNode|TContainerNode|null;\n\n  stylingTemplate: StylingContext|null;\n  /**\n   * List of projected TNodes for a given component host element OR index into the said nodes.\n   *\n   * For easier discussion assume this example:\n   * `<parent>`'s view definition:\n   * ```\n   * <child id=\"c1\">content1</child>\n   * <child id=\"c2\"><span>content2</span></child>\n   * ```\n   * `<child>`'s view definition:\n   * ```\n   * <ng-content id=\"cont1\"></ng-content>\n   * ```\n   *\n   * If `Array.isArray(projection)` then `TNode` is a host element:\n   * - `projection` stores the content nodes which are to be projected.\n   *    - The nodes represent categories defined by the selector: For example:\n   *      `<ng-content/><ng-content select=\"abc\"/>` would represent the heads for `<ng-content/>`\n   *      and `<ng-content select=\"abc\"/>` respectively.\n   *    - The nodes we store in `projection` are heads only, we used `.next` to get their\n   *      siblings.\n   *    - The nodes `.next` is sorted/rewritten as part of the projection setup.\n   *    - `projection` size is equal to the number of projections `<ng-content>`. The size of\n   *      `c1` will be `1` because `<child>` has only one `<ng-content>`.\n   * - we store `projection` with the host (`c1`, `c2`) rather than the `<ng-content>` (`cont1`)\n   *   because the same component (`<child>`) can be used in multiple locations (`c1`, `c2`) and as\n   *   a result have different set of nodes to project.\n   * - without `projection` it would be difficult to efficiently traverse nodes to be projected.\n   *\n   * If `typeof projection == 'number'` then `TNode` is a `<ng-content>` element:\n   * - `projection` is an index of the host's `projection`Nodes.\n   *   - This would return the first head node to project:\n   *     `getHost(currentTNode).projection[currentTNode.projection]`.\n   * - When projecting nodes the parent node retrieved may be a `<ng-content>` node, in which case\n   *   the process is recursive in nature (not implementation).\n   *\n   * If `projection` is of type `RNode[][]` than we have a collection of native nodes passed as\n   * projectable nodes during dynamic component creation.\n   */\n  projection: (TNode|RNode[])[]|number|null;\n\n  /**\n   * A buffer of functions that will be called once `elementEnd` (or `element`) completes.\n   *\n   * Due to the nature of how directives work in Angular, some directive code may\n   * need to fire after any template-level code runs. If present, this array will\n   * be flushed (each function will be invoked) once the associated element is\n   * created.\n   *\n   * If an element is created multiple times then this function will be populated\n   * with functions each time the creation block is called.\n   */\n  onElementCreationFns: Function[]|null;\n  // TODO (matsko): rename this to `styles` once the old styling impl is gone\n  newStyles: TStylingContext|null;\n  // TODO (matsko): rename this to `classes` once the old styling impl is gone\n  newClasses: TStylingContext|null;\n}\n\n/** Static data for an element  */\nexport interface TElementNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: TElementNode|TTextNode|TElementContainerNode|TContainerNode|TProjectionNode|null;\n  /**\n   * Element nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using viewData[HOST_NODE]).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n\n  /**\n   * If this is a component TNode with projection, this will be an array of projected\n   * TNodes or native nodes (see TNode.projection for more info). If it's a regular element node or\n   * a component without projection, it will be null.\n   */\n  projection: (TNode|RNode[])[]|null;\n}\n\n/** Static data for a text node */\nexport interface TTextNode extends TNode {\n  /** Index in the data[] array */\n  index: number;\n  child: null;\n  /**\n   * Text nodes will have parents unless they are the first node of a component or\n   * embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n  projection: null;\n}\n\n/** Static data for an LContainer */\nexport interface TContainerNode extends TNode {\n  /**\n   * Index in the data[] array.\n   *\n   * If it's -1, this is a dynamically created container node that isn't stored in\n   * data[] (e.g. when you inject ViewContainerRef) .\n   */\n  index: number;\n  child: null;\n\n  /**\n   * Container nodes will have parents unless:\n   *\n   * - They are the first node of a component or embedded view\n   * - They are dynamically created\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: TView|TView[]|null;\n  projection: null;\n}\n\n/** Static data for an <ng-container> */\nexport interface TElementContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: TElementNode|TTextNode|TContainerNode|TElementContainerNode|TProjectionNode|null;\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n  projection: null;\n}\n\n/** Static data for an ICU expression */\nexport interface TIcuContainerNode extends TNode {\n  /** Index in the LView[] array. */\n  index: number;\n  child: TElementNode|TTextNode|null;\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n  projection: null;\n  /**\n   * Indicates the current active case for an ICU expression.\n   * It is null when there is no active case.\n   */\n  activeCaseIndex: number|null;\n}\n\n/** Static data for a view  */\nexport interface TViewNode extends TNode {\n  /** If -1, it's a dynamically created view. Otherwise, it is the view block ID. */\n  index: number;\n  child: TElementNode|TTextNode|TElementContainerNode|TContainerNode|TProjectionNode|null;\n  parent: TContainerNode|null;\n  tViews: null;\n  projection: null;\n}\n\n/** Static data for an LProjectionNode  */\nexport interface TProjectionNode extends TNode {\n  /** Index in the data[] array */\n  child: null;\n  /**\n   * Projection nodes will have parents unless they are the first node of a component\n   * or embedded view (which means their parent is in a different view and must be\n   * retrieved using LView.node).\n   */\n  parent: TElementNode|TElementContainerNode|null;\n  tViews: null;\n\n  /** Index of the projection node. (See TNode.projection for more info.) */\n  projection: number;\n}\n\n/**\n * This mapping is necessary so we can set input properties and output listeners\n * properly at runtime when property names are minified or aliased.\n *\n * Key: unminified / public input or output name\n * Value: array containing minified / internal name and related directive index\n *\n * The value must be an array to support inputs and outputs with the same name\n * on the same node.\n */\nexport type PropertyAliases = {\n  // This uses an object map because using the Map type would be too slow\n  [key: string]: PropertyAliasValue\n};\n\n/**\n * Store the runtime input or output names for all the directives.\n *\n * i+0: directive instance index\n * i+1: publicName\n * i+2: privateName\n *\n * e.g. [0, 'change', 'change-minified']\n */\nexport type PropertyAliasValue = (number | string)[];\n\n/**\n * This array contains information about input properties that\n * need to be set once from attribute data. It's ordered by\n * directive index (relative to element) so it's simple to\n * look up a specific directive's initial input data.\n *\n * Within each sub-array:\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: initial value\n *\n * If a directive on a node does not have any input properties\n * that should be set from attributes, its index is set to null\n * to avoid a sparse array.\n *\n * e.g. [null, ['role-min', 'minified-input', 'button']]\n */\nexport type InitialInputData = (InitialInputs | null)[];\n\n/**\n * Used by InitialInputData to store input properties\n * that should be set once from attributes.\n *\n * i+0: attribute name\n * i+1: minified/internal input name\n * i+2: initial value\n *\n * e.g. ['role-min', 'minified-input', 'button']\n */\nexport type InitialInputs = string[];\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n\n/**\n * Type representing a set of TNodes that can have local refs (`#foo`) placed on them.\n */\nexport type TNodeWithLocalRefs = TContainerNode | TElementNode | TElementContainerNode;\n\n/**\n * Type for a function that extracts a value for a local refs.\n * Example:\n * - `<div #nativeDivEl>` - `nativeDivEl` should point to the native `<div>` element;\n * - `<ng-template #tplRef>` - `tplRef` should point to the `TemplateRef` instance;\n */\nexport type LocalRefExtractor = (tNode: TNodeWithLocalRefs, currentView: LView) => any;\n"]}

package/esm2015/src/render3/interfaces/projection.js

@@ -25,4 +25,4 @@ export { SelectorFlags };
 // failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvaW50ZXJmYWNlcy9wcm9qZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7SUFnRUUsaUVBQWlFO0lBQ2pFLE1BQVk7SUFFWixtQ0FBbUM7SUFDbkMsWUFBa0I7SUFFbEIsa0NBQWtDO0lBQ2xDLFVBQWdCO0lBRWhCLG9DQUFvQztJQUNwQyxRQUFjOzs7Ozs7QUFLaEIsTUFBTSxPQUFPLDZCQUE2QixHQUFHLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuXG4vKipcbiAqIEV4cHJlc3NlcyBhIHNpbmdsZSBDU1MgU2VsZWN0b3IuXG4gKlxuICogQmVnaW5uaW5nIG9mIGFycmF5XG4gKiAtIEZpcnN0IGluZGV4OiBlbGVtZW50IG5hbWVcbiAqIC0gU3Vic2VxdWVudCBvZGQgaW5kaWNlczogYXR0ciBrZXlzXG4gKiAtIFN1YnNlcXVlbnQgZXZlbiBpbmRpY2VzOiBhdHRyIHZhbHVlc1xuICpcbiAqIEFmdGVyIFNlbGVjdG9yRmxhZ3MuQ0xBU1MgZmxhZ1xuICogLSBDbGFzcyBuYW1lIHZhbHVlc1xuICpcbiAqIFNlbGVjdG9yRmxhZ3MuTk9UIGZsYWdcbiAqIC0gQ2hhbmdlcyB0aGUgbW9kZSB0byBOT1RcbiAqIC0gQ2FuIGJlIGNvbWJpbmVkIHdpdGggb3RoZXIgZmxhZ3MgdG8gc2V0IHRoZSBlbGVtZW50IC8gYXR0ciAvIGNsYXNzIG1vZGVcbiAqXG4gKiBlLmcuIFNlbGVjdG9yRmxhZ3MuTk9UIHwgU2VsZWN0b3JGbGFncy5FTEVNRU5UXG4gKlxuICogRXhhbXBsZTpcbiAqIE9yaWdpbmFsOiBgZGl2LmZvby5iYXJbYXR0cjE9dmFsMV1bYXR0cjJdYFxuICogUGFyc2VkOiBbJ2RpdicsICdhdHRyMScsICd2YWwxJywgJ2F0dHIyJywgJycsIFNlbGVjdG9yRmxhZ3MuQ0xBU1MsICdmb28nLCAnYmFyJ11cbiAqXG4gKiBPcmlnaW5hbDogJ2RpdlthdHRyMV06bm90KC5mb29bYXR0cjJdKVxuICogUGFyc2VkOiBbXG4gKiAgJ2RpdicsICdhdHRyMScsICcnLFxuICogIFNlbGVjdG9yRmxhZ3MuTk9UIHwgU2VsZWN0b3JGbGFncy5BVFRSSUJVVEUgJ2F0dHIyJywgJycsIFNlbGVjdG9yRmxhZ3MuQ0xBU1MsICdmb28nXG4gKiBdXG4gKlxuICogU2VlIG1vcmUgZXhhbXBsZXMgaW4gbm9kZV9zZWxlY3Rvcl9tYXRjaGVyX3NwZWMudHNcbiAqL1xuZXhwb3J0IHR5cGUgQ3NzU2VsZWN0b3IgPSAoc3RyaW5nIHwgU2VsZWN0b3JGbGFncylbXTtcblxuLyoqXG4gKiBBIGxpc3Qgb2YgQ3NzU2VsZWN0b3JzLlxuICpcbiAqIEEgZGlyZWN0aXZlIG9yIGNvbXBvbmVudCBjYW4gaGF2ZSBtdWx0aXBsZSBzZWxlY3RvcnMuIFRoaXMgdHlwZSBpcyB1c2VkIGZvclxuICogZGlyZWN0aXZlIGRlZnMgc28gYW55IG9mIHRoZSBzZWxlY3RvcnMgaW4gdGhlIGxpc3Qgd2lsbCBtYXRjaCB0aGF0IGRpcmVjdGl2ZS5cbiAqXG4gKiBPcmlnaW5hbDogJ2Zvcm0sIFtuZ0Zvcm1dJ1xuICogUGFyc2VkOiBbWydmb3JtJ10sIFsnJywgJ25nRm9ybScsICcnXV1cbiAqL1xuZXhwb3J0IHR5cGUgQ3NzU2VsZWN0b3JMaXN0ID0gQ3NzU2VsZWN0b3JbXTtcblxuLyoqXG4gKiBMaXN0IG9mIHNsb3RzIGZvciBhIHByb2plY3Rpb24uIEEgc2xvdCBjYW4gYmUgZWl0aGVyIGJhc2VkIG9uIGEgcGFyc2VkIENTUyBzZWxlY3RvclxuICogd2hpY2ggd2lsbCBiZSB1c2VkIHRvIGRldGVybWluZSBub2RlcyB3aGljaCBhcmUgcHJvamVjdGVkIGludG8gdGhhdCBzbG90LlxuICpcbiAqIFdoZW4gc2V0IHRvIFwiKlwiLCB0aGUgc2xvdCBpcyByZXNlcnZlZCBhbmQgY2FuIGJlIHVzZWQgZm9yIG11bHRpLXNsb3QgcHJvamVjdGlvblxuICogdXNpbmcge0BsaW5rIFZpZXdDb250YWluZXJSZWYjY3JlYXRlQ29tcG9uZW50fS4gVGhlIGxhc3Qgc2xvdCB0aGF0IHNwZWNpZmllcyB0aGVcbiAqIHdpbGRjYXJkIHNlbGVjdG9yIHdpbGwgcmV0cmlldmUgYWxsIHByb2plY3RhYmxlIG5vZGVzIHdoaWNoIGRvIG5vdCBtYXRjaCBhbnkgc2VsZWN0b3IuXG4gKi9cbmV4cG9ydCB0eXBlIFByb2plY3Rpb25TbG90cyA9IChDc3NTZWxlY3Rvckxpc3QgfCAnKicpW107XG5cbi8qKiBGbGFncyB1c2VkIHRvIGJ1aWxkIHVwIENzc1NlbGVjdG9ycyAqL1xuZXhwb3J0IGNvbnN0IGVudW0gU2VsZWN0b3JGbGFncyB7XG4gIC8qKiBJbmRpY2F0ZXMgdGhpcyBpcyB0aGUgYmVnaW5uaW5nIG9mIGEgbmV3IG5lZ2F0aXZlIHNlbGVjdG9yICovXG4gIE5PVCA9IDBiMDAwMSxcblxuICAvKiogTW9kZSBmb3IgbWF0Y2hpbmcgYXR0cmlidXRlcyAqL1xuICBBVFRSSUJVVEUgPSAwYjAwMTAsXG5cbiAgLyoqIE1vZGUgZm9yIG1hdGNoaW5nIHRhZyBuYW1lcyAqL1xuICBFTEVNRU5UID0gMGIwMTAwLFxuXG4gIC8qKiBNb2RlIGZvciBtYXRjaGluZyBjbGFzcyBuYW1lcyAqL1xuICBDTEFTUyA9IDBiMTAwMCxcbn1cblxuLy8gTm90ZTogVGhpcyBoYWNrIGlzIG5lY2Vzc2FyeSBzbyB3ZSBkb24ndCBlcnJvbmVvdXNseSBnZXQgYSBjaXJjdWxhciBkZXBlbmRlbmN5XG4vLyBmYWlsdXJlIGJhc2VkIG9uIHR5cGVzLlxuZXhwb3J0IGNvbnN0IHVudXNlZFZhbHVlRXhwb3J0VG9QbGFjYXRlQWpkID0gMTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/render3/interfaces/styling.js

@@ -41,7 +41,7 @@
  * Once the styling context is created then single and multi properties can be stored within it.
  * For this to happen, the following function needs to be called:
  *
- * `elementStyling` (called with style properties, class properties and a sanitizer + a directive
+ * `styling` (called with style properties, class properties and a sanitizer + a directive
  * instance).
  *
  * When this instruction is called it will populate the styling context with the provided style
@@ -112,8 +112,8 @@
  * values are and how they work.
  *
  * Each time a binding property is updated (whether it be through a single
- * property instruction like `elementStyleProp`, `elementClassProp` or
- * `elementStylingMap`) then the values in the context will be updated as
+ * property instruction like `styleProp`, `classProp`,
+ * `styleMap` or `classMap`) then the values in the context will be updated as
  * well.
  *
  * If for example `[style.width]` updates to `555px` then its value will be reflected
@@ -132,9 +132,9 @@
  *
  * Despite the context being updated, nothing has been rendered on screen (not styles or
  * classes have been set on the element). To kick off rendering for an element the following
- * function needs to be run `elementStylingApply`.
+ * function needs to be run `stylingApply`.
  *
- * `elementStylingApply` will run through the context and find each dirty value and render them onto
+ * `stylingApply` will run through the context and find each dirty value and render them onto
  * the element. Once complete, all styles/classes will be set to clean. Because of this, the render
  * function will now know not to rerun itself again if called again unless new style/class values
  * have changed.
@@ -148,11 +148,12 @@
  * Each of the following instructions supports accepting a directive instance as an input parameter:
  *
  * - `elementHostAttrs`
- * - `elementStyling`
- * - `elementStyleProp`
- * - `elementClassProp`
- * - `elementStylingMap`
- * - `elementStylingApply`
+ * - `styling`
+ * - `styleProp`
+ * - `classProp`
+ * - `styleMap`
+ * - `classMap`
+ * - `stylingApply`
  *
  * Each time a directive value is passed in, it will be converted into an index by examining the
  * directive registry (which lives in the context configuration area). The index is then used
@@ -246,7 +247,7 @@
  *
  * ## Rendering
  * The rendering mechanism (when the styling data is applied on screen) occurs via the
- * `elementStylingApply` function and is designed to run after **all** styling functions have been
+ * `stylingApply` function and is designed to run after **all** styling functions have been
  * evaluated. The rendering algorithm will loop over the context and only apply the styles that are
  * flagged as dirty (either because they are new, updated or have been removed via multi or
  * single bindings).
@@ -280,7 +281,7 @@ if (false) {
  * the styling is applied).
  *
  * This queue is used when any `hostStyling` instructions are executed from the `hostBindings`
- * function. Template-level styling functions (e.g. `elementStylingMap` and `elementClassProp`)
+ * function. Template-level styling functions (e.g. `styleMap` and `classProp`)
  * do not make use of this queue (they are applied to the styling context immediately).
  *
  * Due to the nature of how components/directives are evaluated, directives (both parent and
@@ -314,7 +315,7 @@ if (false) {
  * inside of `renderStyling`).
  *
  * Right now each directive's hostBindings function, as well the template function, both
- * call `elementStylingApply()` and `hostStylingApply()`. The fact that this is called
+ * call `stylingApply()` and `hostStylingApply()`. The fact that this is called
  * multiple times for the same element (b/c of change detection) causes some issues. To avoid
  * having styling code be rendered on an element multiple times, the `HostInstructionsQueue`
  * reserves a slot for a reference pointing to the very last directive that was registered and
@@ -614,11 +615,11 @@ export { DirectiveOwnerAndPlayerBuilderIndex };
 /**
  * The default directive styling index value for template-based bindings.
  *
- * All host-level bindings (e.g. `hostStyleProp` and `hostStylingMap`) are
+ * All host-level bindings (e.g. `hostStyleProp` and `hostClassMap`) are
  * assigned a directive styling index value based on the current directive
  * uniqueId and the directive super-class inheritance depth. But for template
  * bindings they always have the same directive styling index value.
  * @type {?}
  */
 export const DEFAULT_TEMPLATE_DIRECTIVE_INDEX = 0;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuQA,oCAoEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDD,2CAA4F;;;;;;;IAM1F,uCAAwC;IACxC,sBAAuB;IACvB,uBAAwB;IACxB,sBAAuB;IACvB,eAAgB;IAChB,OAAQ;;;;;;;;;;;AAUV,0CAGC;;;;;;;;;IA0GC;;OAEG;IACH,2BAA4B;IAE5B;;;;;;;;;OASG;IACH,4BAA6B;IAE7B;;OAEG;IACH,wBAAyB;IAEzB;;OAEG;IACH,aAAc;IAEd;;OAEG;IACH,cAAe;IAEf;;;OAGG;IACH,uBAAwB;IAExB;;OAEG;IACH,yBAA4B;IAC5B,uBAAwB;IAExB;;OAEG;IACH,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BV,6CAGC;;;;;;;;;IAOC,8BAA+B;IAC/B,uBAAwB;IACxB,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BV,4CAGC;;;;;;;;;IAOC,sBAAuB;IACvB,uBAAwB;IACxB,qBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDxB,0CAEC;;;;;;;IAGC,uBAAwB;IACxB,sBAAuB;IACvB,kBAAmB;IACnB,sBAAuB;IACvB,cAAe;IACf,mBAAoB;IACpB,OAAQ;;;;;IAQR,4BAA4B;IAC5B,OAAc;IACd,sDAAsD;IACtD,QAAe;IACf,kDAAkD;IAClD,QAAe;IACf,0DAA0D;IAC1D,WAAkB;IAClB,wEAAwE;IACxE,sBAA6B;IAC7B,sEAAsE;IACtE,2BAAiC;IACjC,eAAgB;IAChB,gCAAgC;IAChC,WAAiB;;;;;IAKjB,yEAAyE;IACzE,0DAA0D;IAC1D,kBAAmB;IACnB,yFAAyF;IACzF,qBAAsB;IACtB,6EAA6E;IAC7E,4BAA6B;IAC7B,yEAAyE;IACzE,6BAA8B;IAC9B,6BAA8B;IAC9B,kEAAkE;IAClE,4BAA6B;IAC7B,iGAAiG;IACjG,sDAAsD;IACtD,qBAAsB;IACtB,qEAAqE;IACrE,oBAAqB;IACrB,iGAAiG;IACjG,yEAAyE;IACzE,wBAAyB;IACzB,gBAAiB;IACjB,wEAAwE;IACxE,6BAA8B;IAC9B,cAAe;IACf,iBAAkB;IAClB,cAAe;IACf,2BAA4B;IAC5B,gFAAgF;IAChF,OAAQ;IACR,oDAAoD;IACpD,gBAAiB;IACjB,mCAAmC;IACnC,cAA0B;;;;;IAY1B,gBAAiB;IACjB,cAA4B;;;;;;;;;;;;AAW9B,MAAM,OAAO,gCAAgC,GAAG,CAAC","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 */\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {RElement} from '../interfaces/renderer';\nimport {LContainer} from './container';\nimport {PlayerContext} from './player';\nimport {LView} from './view';\n\n\n/**\n * The styling context acts as a styling manifest (shaped as an array) for determining which\n * styling properties have been assigned via the provided `updateStylingMap`, `updateStyleProp`\n * and `updateClassProp` functions. It also stores the static style/class values that were\n * extracted from the template by the compiler.\n *\n * A context is created by Angular when:\n * 1. An element contains static styling values (like style=\"...\" or class=\"...\")\n * 2. An element contains single property binding values (like [style.prop]=\"x\" or\n * [class.prop]=\"y\")\n * 3. An element contains multi property binding values (like [style]=\"x\" or [class]=\"y\")\n * 4. A directive contains host bindings for static, single or multi styling properties/bindings.\n * 5. An animation player is added to an element via `addPlayer`\n *\n * Note that even if an element contains static styling then this context will be created and\n * attached to it. The reason why this happens (instead of treating styles/classes as regular\n * HTML attributes) is because the style/class bindings must be able to default themselves back\n * to their respective static values when they are set to null.\n *\n * Say for example we have this:\n * ```\n * <!-- when `myWidthExp=null` then a width of `100px`\n *      will be used a default value for width -->\n * <div style=\"width:100px\" [style.width]=\"myWidthExp\"></div>\n * ```\n *\n * Even in the situation where there are no bindings, the static styling is still placed into the\n * context because there may be another directive on the same element that has styling.\n *\n * When Angular initializes styling data for an element then it will first register the static\n * styling values on the element using one of these two instructions:\n *\n * 1. elementStart or element (within the template function of a component)\n * 2. elementHostAttrs (for directive host bindings)\n *\n * In either case, a styling context will be created and stored within an element's `LViewData`.\n * Once the styling context is created then single and multi properties can be stored within it.\n * For this to happen, the following function needs to be called:\n *\n * `elementStyling` (called with style properties, class properties and a sanitizer + a directive\n * instance).\n *\n * When this instruction is called it will populate the styling context with the provided style\n * and class names into the context.\n *\n * The context itself looks like this:\n *\n * context = [\n *   // 0-8: header values (about 8 entries of configuration data)\n *   // 9+: this is where each entry is stored:\n * ]\n *\n * Let's say we have the following template code:\n *\n * ```\n * <div class=\"foo bar\"\n *      style=\"width:200px; color:red\"\n *      [style.width]=\"myWidthExp\"\n *      [style.height]=\"myHeightExp\"\n *      [class.baz]=\"myBazExp\">\n * ```\n *\n * The context generated from these values will look like this (note that\n * for each binding name (the class and style bindings) the values will\n * be inserted twice into the array (once for single property entries and\n * again for multi property entries).\n *\n * context = [\n *   // 0-8: header values (about 8 entries of configuration data)\n *   // 9+: this is where each entry is stored:\n *\n *   // SINGLE PROPERTIES\n *   configForWidth,\n *   'width'\n *   myWidthExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForHeight,\n *   'height'\n *   myHeightExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForBazClass,\n *   'baz\n *   myBazClassExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   // MULTI PROPERTIES\n *   configForWidth,\n *   'width'\n *   myWidthExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForHeight,\n *   'height'\n *   myHeightExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForBazClass,\n *   'baz\n *   myBazClassExp, // the binding value not the binding itself\n *   0, // the directive owner\n * ]\n *\n * The configuration values are left out of the example above because\n * the ordering of them could change between code patches. Please read the\n * documentation below to get a better understand of what the configuration\n * values are and how they work.\n *\n * Each time a binding property is updated (whether it be through a single\n * property instruction like `elementStyleProp`, `elementClassProp` or\n * `elementStylingMap`) then the values in the context will be updated as\n * well.\n *\n * If for example `[style.width]` updates to `555px` then its value will be reflected\n * in the context as so:\n *\n * context = [\n *   // ...\n *   configForWidth, // this will be marked DIRTY\n *   'width'\n *   '555px',\n *   0,\n *   //..\n * ]\n *\n * The context and directive data will also be marked dirty.\n *\n * Despite the context being updated, nothing has been rendered on screen (not styles or\n * classes have been set on the element). To kick off rendering for an element the following\n * function needs to be run `elementStylingApply`.\n *\n * `elementStylingApply` will run through the context and find each dirty value and render them onto\n * the element. Once complete, all styles/classes will be set to clean. Because of this, the render\n * function will now know not to rerun itself again if called again unless new style/class values\n * have changed.\n *\n * ## Directives\n * Directive style/class values (which are provided through host bindings) are also supported and\n * housed within the same styling context as are template-level style/class properties/bindings\n * So long as they are all assigned to the same element, both directive-level and template-level\n * styling bindings share the same context.\n *\n * Each of the following instructions supports accepting a directive instance as an input parameter:\n *\n * - `elementHostAttrs`\n * - `elementStyling`\n * - `elementStyleProp`\n * - `elementClassProp`\n * - `elementStylingMap`\n * - `elementStylingApply`\n *\n * Each time a directive value is passed in, it will be converted into an index by examining the\n * directive registry (which lives in the context configuration area). The index is then used\n * to help single style properties figure out where a value is located in the context.\n *\n *\n * ## Single-level styling bindings (`[style.prop]` and `[class.name]`)\n *\n * Both `[style.prop]` and `[class.name]` bindings are run through the `updateStyleProp`\n * and `updateClassProp` functions respectively. They work by examining the provided\n * `offset` value and are able to locate the exact spot in the context where the\n * matching style is located.\n *\n * Both `[style.prop]` and `[class.name]` bindings are able to process these values\n * from directive host bindings. When evaluated (from the host binding function) the\n * `directiveRef` value is then passed in.\n *\n * If two directives or a directive + a template binding both write to the same style/class\n * binding then the styling context code will decide which one wins based on the following\n * rule:\n *\n * 1. If the template binding has a value then it always wins\n * 2. Otherwise whichever first-registered directive that has that value first will win\n *\n * The code example helps make this clear:\n *\n * ```\n * <!--\n * <div [style.width]=\"myWidth\"\n *      [my-width-directive]=\"'600px'\">\n * -->\n *\n * @Directive({\n *  selector: '[my-width-directive']\n * })\n * class MyWidthDirective {\n *   @Input('my-width-directive')\n *   @HostBinding('style.width')\n *   public width = null;\n * }\n * ```\n *\n * Since there is a style binding for width present on the element (`[style.width]`) then\n * it will always win over the width binding that is present as a host binding within\n * the `MyWidthDirective`. However, if `[style.width]` renders as `null` (so `myWidth=null`)\n * then the `MyWidthDirective` will be able to write to the `width` style within the context.\n * Simply put, whichever directive writes to a value first ends up having ownership of it as\n * long as the template didn't set anything.\n *\n * The way in which the ownership is facilitated is through index value. The earliest directives\n * get the smallest index values (with 0 being reserved for the template element bindings). Each\n * time a value is written from a directive or the template bindings, the value itself gets\n * assigned the directive index value in its data. If another directive writes a value again then\n * its directive index gets compared against the directive index that exists on the element. Only\n * when the new value's directive index is less than the existing directive index then the new\n * value will be written to the context. But, if the existing value is null then the new value is\n * written by the less important directive.\n *\n * Each directive also has its own sanitizer and dirty flags. These values are consumed within the\n * rendering function.\n *\n *\n * ## Multi-level styling bindings (`[style]` and `[class]`)\n *\n * Multi-level styling bindings are treated as less important (less specific) as single-level\n * bindings (things like `[style.prop]` and `[class.name]`).\n *\n * Multi-level bindings are still applied to the context in a similar way as are single level\n * bindings, but this process works by diffing the new multi-level values (which are key/value\n * maps) against the existing set of styles that live in the context. Each time a new map value\n * is detected (via identity check) then it will loop through the values and figure out what\n * has changed and reorder the context array to match the ordering of the keys. This reordering\n * of the context makes sure that follow-up traversals of the context when updated against the\n * key/value map are as close as possible to o(n) (where \"n\" is the size of the key/value map).\n *\n * If a `directiveRef` value is passed in then the styling algorithm code will take the directive's\n * prioritization index into account and update the values with respect to more important\n * directives. This means that if a value such as `width` is updated in two different `[style]`\n * bindings (say one on the template and another within a directive that sits on the same element)\n * then the algorithm will decide how to update the value based on the following heuristic:\n *\n * 1. If the template binding has a value then it always wins\n * 2. If not then whichever first-registered directive that has that value first will win\n *\n * It will also update the value if it was set to `null` by a previous directive (or the template).\n *\n * Each time a value is updated (or removed) then the context will change shape to better match\n * the ordering of the styling data as well as the ordering of each directive that contains styling\n * data. (See `patchStylingMapIntoContext` inside of class_and_style_bindings.ts to better\n * understand how this works.)\n *\n * ## Rendering\n * The rendering mechanism (when the styling data is applied on screen) occurs via the\n * `elementStylingApply` function and is designed to run after **all** styling functions have been\n * evaluated. The rendering algorithm will loop over the context and only apply the styles that are\n * flagged as dirty (either because they are new, updated or have been removed via multi or\n * single bindings).\n */\nexport interface StylingContext extends\n    Array<{[key: string]: any}|number|string|boolean|RElement|StyleSanitizeFn|PlayerContext|null> {\n  /**\n   * Location of element that is used as a target for this context.\n   */\n  [StylingIndex.ElementPosition]: LContainer|LView|RElement|null;\n\n  /**\n   * A numeric value representing the configuration status (whether the context is dirty or not)\n   * mixed together (using bit shifting) with a index value which tells the starting index value\n   * of where the multi style entries begin.\n   */\n  [StylingIndex.MasterFlagPosition]: number;\n\n  /**\n   * Location of the collection of directives for this context\n   */\n  [StylingIndex.DirectiveRegistryPosition]: DirectiveRegistryValues;\n\n  /**\n   * Location of all static styles values\n   */\n  [StylingIndex.InitialStyleValuesPosition]: InitialStylingValues;\n\n  /**\n   * Location of all static class values\n   */\n  [StylingIndex.InitialClassValuesPosition]: InitialStylingValues;\n\n  /**\n   * A numeric value representing the class index offset value. Whenever a single class is\n   * applied (using `elementClassProp`) it should have an styling index value that doesn't\n   * need to take into account any style values that exist in the context.\n   */\n  [StylingIndex.SinglePropOffsetPositions]: SinglePropOffsetValues;\n\n  /**\n   * The last class value that was interpreted by elementStylingMap. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.CachedMultiClasses]: any|MapBasedOffsetValues;\n\n  /**\n   * The last style value that was interpreted by elementStylingMap. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.CachedMultiStyles]: any|MapBasedOffsetValues;\n\n  /**\n   * A queue of all hostStyling instructions.\n   *\n   * This array (queue) is populated only when host-level styling instructions\n   * (e.g. `hostStylingMap` and `hostClassProp`) are used to apply style and\n   * class values via host bindings to the host element. Despite these being\n   * standard angular instructions, they are not designed to immediately apply\n   * their values to the styling context when executed. What happens instead is\n   * a queue is constructed and each instruction is populated into the queue.\n   * Then, once the style/class values are set to flush (via `elementStylingApply` or\n   * `hostStylingApply`), the queue is flushed and the values are rendered onto\n   * the host element.\n   */\n  [StylingIndex.HostInstructionsQueue]: HostInstructionsQueue|null;\n\n  /**\n   * Location of animation context (which contains the active players) for this element styling\n   * context.\n   */\n  [StylingIndex.PlayerContext]: PlayerContext|null;\n}\n\n/**\n * A queue of all host-related styling instructions (these are buffered and evaluated just before\n * the styling is applied).\n *\n * This queue is used when any `hostStyling` instructions are executed from the `hostBindings`\n * function. Template-level styling functions (e.g. `elementStylingMap` and `elementClassProp`)\n * do not make use of this queue (they are applied to the styling context immediately).\n *\n * Due to the nature of how components/directives are evaluated, directives (both parent and\n * subclass directives) may not apply their styling at the right time for the styling\n * algorithm code to prioritize them. Therefore, all host-styling instructions are queued up\n * (buffered) into the array below and are automatically sorted in terms of priority. The\n * priority for host-styling is as follows:\n *\n * 1. The template (this doesn't get queued, but gets evaluated immediately)\n * 2. Any directives present on the host\n *   2a) first child directive styling bindings are updated\n *   2b) then any parent directives\n * 3. Component host bindings\n *\n * Angular runs change detection for each of these cases in a different order. Because of this\n * the array below is populated with each of the host styling functions + their arguments.\n *\n * context[HostInstructionsQueue] = [\n *   directiveIndex,\n *   hostStylingFn,\n *   [argumentsForFn],\n *   ...\n *   anotherDirectiveIndex, <-- this has a lower priority (a higher directive index)\n *   anotherHostStylingFn,\n *   [argumentsForFn],\n * ]\n *\n * When `renderStyling` is called (within `class_and_host_bindings.ts`) then the queue is\n * drained and each of the instructions are executed. Once complete the queue is empty then\n * the style/class binding code is rendered on the element (which is what happens normally\n * inside of `renderStyling`).\n *\n * Right now each directive's hostBindings function, as well the template function, both\n * call `elementStylingApply()` and `hostStylingApply()`. The fact that this is called\n * multiple times for the same element (b/c of change detection) causes some issues. To avoid\n * having styling code be rendered on an element multiple times, the `HostInstructionsQueue`\n * reserves a slot for a reference pointing to the very last directive that was registered and\n * only allows for styling to be applied once that directive is encountered (which will happen\n * as the last update for that element).\n */\nexport interface HostInstructionsQueue extends Array<number|Function|any[]> { [0]: number; }\n\n/**\n * Used as a reference for any values contained within `HostInstructionsQueue`.\n */\nexport const enum HostInstructionsQueueIndex {\n  LastRegisteredDirectiveIndexPosition = 0,\n  ValuesStartPosition = 1,\n  DirectiveIndexOffset = 0,\n  InstructionFnOffset = 1,\n  ParamsOffset = 2,\n  Size = 3,\n}\n\n/**\n * Used as a styling array to house static class and style values that were extracted\n * by the compiler and placed in the animation context via `elementStart` and\n * `elementHostAttrs`.\n *\n * See [InitialStylingValuesIndex] for a breakdown of how all this works.\n */\nexport interface InitialStylingValues extends Array<string|boolean|number|null> {\n  [InitialStylingValuesIndex.DefaultNullValuePosition]: null;\n  [InitialStylingValuesIndex.CachedStringValuePosition]: string|null;\n}\n\n/**\n * Used as an offset/position index to figure out where initial styling\n * values are located.\n *\n * Used as a reference point to provide markers to all static styling\n * values (the initial style and class values on an element) within an\n * array within the `StylingContext`. This array contains key/value pairs\n * where the key is the style property name or className and the value is\n * the style value or whether or not a class is present on the elment.\n *\n * The first value is always null so that a initial index value of\n * `0` will always point to a null value.\n *\n * The second value is also always null unless a string-based representation\n * of the styling data was constructed (it gets cached in this slot).\n *\n * If a <div> elements contains a list of static styling values like so:\n *\n * <div class=\"foo bar baz\" style=\"width:100px; height:200px;\">\n *\n * Then the initial styles for that will look like so:\n *\n * Styles:\n * ```\n * StylingContext[InitialStylesIndex] = [\n *   null, null, 'width', '100px', height, '200px'\n * ]\n * ```\n *\n * Classes:\n * ```\n * StylingContext[InitialClassesIndex] = [\n *   null, null, 'foo', true, 'bar', true, 'baz', true\n * ]\n * ```\n *\n * Initial style and class entries have their own arrays. This is because\n * it's easier to add to the end of one array and not then have to update\n * every context entries' pointer index to the newly offseted values.\n *\n * When property bindinds are added to a context then initial style/class\n * values will also be inserted into the array. This is to create a space\n * in the situation when a follow-up directive inserts static styling into\n * the array. By default, style values are `null` and class values are\n * `false` when inserted by property bindings.\n *\n * For example:\n * ```\n * <div class=\"foo bar baz\"\n *      [class.car]=\"myCarExp\"\n *      style=\"width:100px; height:200px;\"\n *      [style.opacity]=\"myOpacityExp\">\n * ```\n *\n * Will construct initial styling values that look like:\n *\n * Styles:\n * ```\n * StylingContext[InitialStylesIndex] = [\n *   null, null, 'width', '100px', height, '200px', 'opacity', null\n * ]\n * ```\n *\n * Classes:\n * ```\n * StylingContext[InitialClassesIndex] = [\n *   null, null, 'foo', true, 'bar', true, 'baz', true, 'car', false\n * ]\n * ```\n *\n * Now if a directive comes along and introduces `car` as a static\n * class value or `opacity` then those values will be filled into\n * the initial styles array.\n *\n * For example:\n *\n * ```\n * @Directive({\n *   selector: 'opacity-car-directive',\n *   host: {\n *     'style': 'opacity:0.5',\n *     'class': 'car'\n *   }\n * })\n * class OpacityCarDirective {}\n * ```\n *\n * This will render itself as:\n *\n * Styles:\n * ```\n * StylingContext[InitialStylesIndex] = [\n *   null, null, 'width', '100px', height, '200px', 'opacity', '0.5'\n * ]\n * ```\n *\n * Classes:\n * ```\n * StylingContext[InitialClassesIndex] = [\n *   null, null, 'foo', true, 'bar', true, 'baz', true, 'car', true\n * ]\n * ```\n */\nexport const enum InitialStylingValuesIndex {\n  /**\n   * The first value is always `null` so that `styles[0] == null` for unassigned values\n   */\n  DefaultNullValuePosition = 0,\n\n  /**\n   * Used for non-styling code to examine what the style or className string is:\n   * styles: ['width', '100px', 0, 'opacity', null, 0, 'height', '200px', 0]\n   *    => initialStyles[CachedStringValuePosition] = 'width:100px;height:200px';\n   * classes: ['foo', true, 0, 'bar', false, 0, 'baz', true, 0]\n   *    => initialClasses[CachedStringValuePosition] = 'foo bar';\n   *\n   * Note that this value is `null` by default and it will only be populated\n   * once `getInitialStyleStringValue` or `getInitialClassNameValue` is executed.\n   */\n  CachedStringValuePosition = 1,\n\n  /**\n   * Where the style or class values start in the tuple\n   */\n  KeyValueStartPosition = 2,\n\n  /**\n   * The offset value (index + offset) for the property value for each style/class entry\n   */\n  PropOffset = 0,\n\n  /**\n   * The offset value (index + offset) for the style/class value for each style/class entry\n   */\n  ValueOffset = 1,\n\n  /**\n   * The offset value (index + offset) for the style/class directive owner for each style/class\n     entry\n   */\n  DirectiveOwnerOffset = 2,\n\n  /**\n   * The first bit set aside to mark if the initial style was already rendere\n   */\n  AppliedFlagBitPosition = 0b0,\n  AppliedFlagBitLength = 1,\n\n  /**\n   * The total size for each style/class entry (prop + value + directiveOwner)\n   */\n  Size = 3\n}\n\n/**\n * An array located in the StylingContext that houses all directive instances and additional\n * data about them.\n *\n * Each entry in this array represents a source of where style/class binding values could\n * come from. By default, there is always at least one directive here with a null value and\n * that represents bindings that live directly on an element in the template (not host bindings).\n *\n * Each successive entry in the array is an actual instance of a directive as well as some\n * additional info about that entry.\n *\n * An entry within this array has the following values:\n * [0] = The instance of the directive (the first entry is null because its reserved for the\n *       template)\n * [1] = The pointer that tells where the single styling (stuff like [class.foo] and [style.prop])\n *       offset values are located. This value will allow for a binding instruction to find exactly\n *       where a style is located.\n * [2] = Whether or not the directive has any styling values that are dirty. This is used as\n *       reference within the `renderStyling` function to decide whether to skip iterating\n *       through the context when rendering is executed.\n * [3] = The styleSanitizer instance that is assigned to the directive. Although it's unlikely,\n *       a directive could introduce its own special style sanitizer and for this reach each\n *       directive will get its own space for it (if null then the very first sanitizer is used).\n *\n * Each time a new directive is added it will insert these four values at the end of the array.\n * When this array is examined then the resulting directiveIndex will be resolved by dividing the\n * index value by the size of the array entries (so if DirA is at spot 8 then its index will be 2).\n */\nexport interface DirectiveRegistryValues extends Array<null|{}|boolean|number|StyleSanitizeFn> {\n  [DirectiveRegistryValuesIndex.SinglePropValuesIndexOffset]: number;\n  [DirectiveRegistryValuesIndex.StyleSanitizerOffset]: StyleSanitizeFn|null;\n}\n\n/**\n * An enum that outlines the offset/position values for each directive entry and its data\n * that are housed inside of [DirectiveRegistryValues].\n */\nexport const enum DirectiveRegistryValuesIndex {\n  SinglePropValuesIndexOffset = 0,\n  StyleSanitizerOffset = 1,\n  Size = 2\n}\n\n/**\n * An array that contains the index pointer values for every single styling property\n * that exists in the context and for every directive. It also contains the total\n * single styles and single classes that exists in the context as the first two values.\n *\n * Let's say we have the following template code:\n *\n * <div [style.width]=\"myWidth\"\n *      [style.height]=\"myHeight\"\n *      [class.flipped]=\"flipClass\"\n *      directive-with-opacity>\n *      directive-with-foo-bar-classes>\n *\n * We have two directive and template-binding sources,\n * 2 + 1 styles and 1 + 1 classes. When the bindings are\n * registered the SinglePropOffsets array will look like so:\n *\n * s_0/c_0 = template directive value\n * s_1/c_1 = directive one (directive-with-opacity)\n * s_2/c_2 = directive two (directive-with-foo-bar-classes)\n *\n * [3, 2, 2, 1, s_00, s01, c_01, 1, 0, s_10, 0, 1, c_20\n */\nexport interface SinglePropOffsetValues extends Array<number> {\n  [SinglePropOffsetValuesIndex.StylesCountPosition]: number;\n  [SinglePropOffsetValuesIndex.ClassesCountPosition]: number;\n}\n\n/**\n * An enum that outlines the offset/position values for each single prop/class entry\n * that are housed inside of [SinglePropOffsetValues].\n */\nexport const enum SinglePropOffsetValuesIndex {\n  StylesCountPosition = 0,\n  ClassesCountPosition = 1,\n  ValueStartPosition = 2\n}\n\n/**\n * Used a reference for all multi styling values (values that are assigned via the\n * `[style]` and `[class]` bindings).\n *\n * Single-styling properties (things set via `[style.prop]` and `[class.name]` bindings)\n * are not handled using the same approach as multi-styling bindings (such as `[style]`\n * `[class]` bindings).\n *\n * Multi-styling bindings rely on a diffing algorithm to figure out what properties have been added,\n * removed and modified. Multi-styling properties are also evaluated across directives--which means\n * that Angular supports having multiple directives all write to the same `[style]` and `[class]`\n * bindings (using host bindings) even if the `[style]` and/or `[class]` bindings are being written\n * to on the template element.\n *\n * All multi-styling values that are written to an element (whether it be from the template or any\n * directives attached to the element) are all written into the `MapBasedOffsetValues` array. (Note\n * that there are two arrays: one for styles and another for classes.)\n *\n * This array is shaped in the following way:\n *\n * [0]  = The total amount of unique multi-style or multi-class entries that exist currently in the\n *        context.\n * [1+] = Contains an entry of four values ... Each entry is a value assigned by a\n * `[style]`/`[class]`\n *        binding (we call this a **source**).\n *\n *        An example entry looks like so (at a given `i` index):\n *        [i + 0] = Whether or not the value is dirty\n *\n *        [i + 1] = The index of where the map-based values\n *                  (for this **source**) start within the context\n *\n *        [i + 2] = The untouched, last set value of the binding\n *\n *        [i + 3] = The total amount of unqiue binding values that were\n *                  extracted and set into the context. (Note that this value does\n *                  not reflect the total amount of values within the binding\n *                  value (since it's a map), but instead reflects the total values\n *                  that were not used by another directive).\n *\n * Each time a directive (or template) writes a value to a `[class]`/`[style]` binding then the\n * styling diffing algorithm code will decide whether or not to update the value based on the\n * following rules:\n *\n * 1. If a more important directive (either the template or a directive that was registered\n *    beforehand) has written a specific styling value into the context then any follow-up styling\n *    values (set by another directive via its `[style]` and/or `[class]` host binding) will not be\n *    able to set it. This is because the former directive has priorty.\n * 2. Only if a former directive has set a specific styling value to null (whether by actually\n *    setting it to null or not including it in is map value) then a less imporatant directive can\n *    set its own value.\n *\n * ## How the map-based styling algorithm updates itself\n */\nexport interface MapBasedOffsetValues extends Array<any> {\n  [MapBasedOffsetValuesIndex.EntriesCountPosition]: number;\n}\n\nexport const enum MapBasedOffsetValuesIndex {\n  EntriesCountPosition = 0,\n  ValuesStartPosition = 1,\n  DirtyFlagOffset = 0,\n  PositionStartOffset = 1,\n  ValueOffset = 2,\n  ValueCountOffset = 3,\n  Size = 4\n}\n\n/**\n * Used to set the context to be dirty or not both on the master flag (position 1)\n * or for each single/multi property that exists in the context.\n */\nexport const enum StylingFlags {\n  // Implies no configurations\n  None = 0b00000,\n  // Whether or not the entry or context itself is dirty\n  Dirty = 0b00001,\n  // Whether or not this is a class-based assignment\n  Class = 0b00010,\n  // Whether or not a sanitizer was applied to this property\n  Sanitize = 0b00100,\n  // Whether or not any player builders within need to produce new players\n  PlayerBuildersDirty = 0b01000,\n  // The max amount of bits used to represent these configuration values\n  BindingAllocationLocked = 0b10000,\n  BitCountSize = 5,\n  // There are only five bits here\n  BitMask = 0b11111\n}\n\n/** Used as numeric pointer values to determine what cells to update in the `StylingContext` */\nexport const enum StylingIndex {\n  // Position of where the initial styles are stored in the styling context\n  // This index must align with HOST, see interfaces/view.ts\n  ElementPosition = 0,\n  // Index of location where the start of single properties are stored. (`updateStyleProp`)\n  MasterFlagPosition = 1,\n  // Position of where the registered directives exist for this styling context\n  DirectiveRegistryPosition = 2,\n  // Position of where the initial styles are stored in the styling context\n  InitialStyleValuesPosition = 3,\n  InitialClassValuesPosition = 4,\n  // Index of location where the class index offset value is located\n  SinglePropOffsetPositions = 5,\n  // Position of where the last string-based CSS class value was stored (or a cached version of the\n  // initial styles when a [class] directive is present)\n  CachedMultiClasses = 6,\n  // Position of where the last string-based CSS class value was stored\n  CachedMultiStyles = 7,\n  // Multi and single entries are stored in `StylingContext` as: Flag; PropertyName;  PropertyValue\n  // Position of where the initial styles are stored in the styling context\n  HostInstructionsQueue = 8,\n  PlayerContext = 9,\n  // Location of single (prop) value entries are stored within the context\n  SingleStylesStartPosition = 10,\n  FlagsOffset = 0,\n  PropertyOffset = 1,\n  ValueOffset = 2,\n  PlayerBuilderIndexOffset = 3,\n  // Size of each multi or single entry (flag + prop + value + playerBuilderIndex)\n  Size = 4,\n  // Each flag has a binary digit length of this value\n  BitCountSize = 14,  // (32 - 4) / 2 = ~14\n  // The binary digit value as a mask\n  BitMask = 0b11111111111111,  // 14 bits\n}\n\n/**\n * An enum that outlines the bit flag data for directive owner and player index\n * values that exist within en entry that lives in the StylingContext.\n *\n * The values here split a number value into two sets of bits:\n *  - The first 16 bits are used to store the directiveIndex that owns this style value\n *  - The other 16 bits are used to store the playerBuilderIndex that is attached to this style\n */\nexport const enum DirectiveOwnerAndPlayerBuilderIndex {\n  BitCountSize = 16,\n  BitMask = 0b1111111111111111\n}\n\n/**\n * The default directive styling index value for template-based bindings.\n *\n * All host-level bindings (e.g. `hostStyleProp` and `hostStylingMap`) are\n * assigned a directive styling index value based on the current directive\n * uniqueId and the directive super-class inheritance depth. But for template\n * bindings they always have the same directive styling index value.\n */\nexport const DEFAULT_TEMPLATE_DIRECTIVE_INDEX = 0;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwQA,oCAoEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDD,2CAA4F;;;;;;;IAM1F,uCAAwC;IACxC,sBAAuB;IACvB,uBAAwB;IACxB,sBAAuB;IACvB,eAAgB;IAChB,OAAQ;;;;;;;;;;;AAUV,0CAGC;;;;;;;;;IA0GC;;OAEG;IACH,2BAA4B;IAE5B;;;;;;;;;OASG;IACH,4BAA6B;IAE7B;;OAEG;IACH,wBAAyB;IAEzB;;OAEG;IACH,aAAc;IAEd;;OAEG;IACH,cAAe;IAEf;;;OAGG;IACH,uBAAwB;IAExB;;OAEG;IACH,yBAA4B;IAC5B,uBAAwB;IAExB;;OAEG;IACH,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BV,6CAGC;;;;;;;;;IAOC,8BAA+B;IAC/B,uBAAwB;IACxB,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BV,4CAGC;;;;;;;;;IAOC,sBAAuB;IACvB,uBAAwB;IACxB,qBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDxB,0CAEC;;;;;;;IAGC,uBAAwB;IACxB,sBAAuB;IACvB,kBAAmB;IACnB,sBAAuB;IACvB,cAAe;IACf,mBAAoB;IACpB,OAAQ;;;;;IAQR,4BAA4B;IAC5B,OAAc;IACd,sDAAsD;IACtD,QAAe;IACf,kDAAkD;IAClD,QAAe;IACf,0DAA0D;IAC1D,WAAkB;IAClB,wEAAwE;IACxE,sBAA6B;IAC7B,sEAAsE;IACtE,2BAAiC;IACjC,eAAgB;IAChB,gCAAgC;IAChC,WAAiB;;;;;IAKjB,yEAAyE;IACzE,0DAA0D;IAC1D,kBAAmB;IACnB,yFAAyF;IACzF,qBAAsB;IACtB,6EAA6E;IAC7E,4BAA6B;IAC7B,yEAAyE;IACzE,6BAA8B;IAC9B,6BAA8B;IAC9B,kEAAkE;IAClE,4BAA6B;IAC7B,iGAAiG;IACjG,sDAAsD;IACtD,qBAAsB;IACtB,qEAAqE;IACrE,oBAAqB;IACrB,iGAAiG;IACjG,yEAAyE;IACzE,wBAAyB;IACzB,gBAAiB;IACjB,wEAAwE;IACxE,6BAA8B;IAC9B,cAAe;IACf,iBAAkB;IAClB,cAAe;IACf,2BAA4B;IAC5B,gFAAgF;IAChF,OAAQ;IACR,oDAAoD;IACpD,gBAAiB;IACjB,mCAAmC;IACnC,cAA0B;;;;;IAY1B,gBAAiB;IACjB,cAA4B;;;;;;;;;;;;AAW9B,MAAM,OAAO,gCAAgC,GAAG,CAAC","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 */\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {RElement} from '../interfaces/renderer';\nimport {LContainer} from './container';\nimport {PlayerContext} from './player';\nimport {LView} from './view';\n\n\n/**\n * The styling context acts as a styling manifest (shaped as an array) for determining which\n * styling properties have been assigned via the provided `updateStylingMap`, `updateStyleProp`\n * and `updateClassProp` functions. It also stores the static style/class values that were\n * extracted from the template by the compiler.\n *\n * A context is created by Angular when:\n * 1. An element contains static styling values (like style=\"...\" or class=\"...\")\n * 2. An element contains single property binding values (like [style.prop]=\"x\" or\n * [class.prop]=\"y\")\n * 3. An element contains multi property binding values (like [style]=\"x\" or [class]=\"y\")\n * 4. A directive contains host bindings for static, single or multi styling properties/bindings.\n * 5. An animation player is added to an element via `addPlayer`\n *\n * Note that even if an element contains static styling then this context will be created and\n * attached to it. The reason why this happens (instead of treating styles/classes as regular\n * HTML attributes) is because the style/class bindings must be able to default themselves back\n * to their respective static values when they are set to null.\n *\n * Say for example we have this:\n * ```\n * <!-- when `myWidthExp=null` then a width of `100px`\n *      will be used a default value for width -->\n * <div style=\"width:100px\" [style.width]=\"myWidthExp\"></div>\n * ```\n *\n * Even in the situation where there are no bindings, the static styling is still placed into the\n * context because there may be another directive on the same element that has styling.\n *\n * When Angular initializes styling data for an element then it will first register the static\n * styling values on the element using one of these two instructions:\n *\n * 1. elementStart or element (within the template function of a component)\n * 2. elementHostAttrs (for directive host bindings)\n *\n * In either case, a styling context will be created and stored within an element's `LViewData`.\n * Once the styling context is created then single and multi properties can be stored within it.\n * For this to happen, the following function needs to be called:\n *\n * `styling` (called with style properties, class properties and a sanitizer + a directive\n * instance).\n *\n * When this instruction is called it will populate the styling context with the provided style\n * and class names into the context.\n *\n * The context itself looks like this:\n *\n * context = [\n *   // 0-8: header values (about 8 entries of configuration data)\n *   // 9+: this is where each entry is stored:\n * ]\n *\n * Let's say we have the following template code:\n *\n * ```\n * <div class=\"foo bar\"\n *      style=\"width:200px; color:red\"\n *      [style.width]=\"myWidthExp\"\n *      [style.height]=\"myHeightExp\"\n *      [class.baz]=\"myBazExp\">\n * ```\n *\n * The context generated from these values will look like this (note that\n * for each binding name (the class and style bindings) the values will\n * be inserted twice into the array (once for single property entries and\n * again for multi property entries).\n *\n * context = [\n *   // 0-8: header values (about 8 entries of configuration data)\n *   // 9+: this is where each entry is stored:\n *\n *   // SINGLE PROPERTIES\n *   configForWidth,\n *   'width'\n *   myWidthExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForHeight,\n *   'height'\n *   myHeightExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForBazClass,\n *   'baz\n *   myBazClassExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   // MULTI PROPERTIES\n *   configForWidth,\n *   'width'\n *   myWidthExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForHeight,\n *   'height'\n *   myHeightExp, // the binding value not the binding itself\n *   0, // the directive owner\n *\n *   configForBazClass,\n *   'baz\n *   myBazClassExp, // the binding value not the binding itself\n *   0, // the directive owner\n * ]\n *\n * The configuration values are left out of the example above because\n * the ordering of them could change between code patches. Please read the\n * documentation below to get a better understand of what the configuration\n * values are and how they work.\n *\n * Each time a binding property is updated (whether it be through a single\n * property instruction like `styleProp`, `classProp`,\n * `styleMap` or `classMap`) then the values in the context will be updated as\n * well.\n *\n * If for example `[style.width]` updates to `555px` then its value will be reflected\n * in the context as so:\n *\n * context = [\n *   // ...\n *   configForWidth, // this will be marked DIRTY\n *   'width'\n *   '555px',\n *   0,\n *   //..\n * ]\n *\n * The context and directive data will also be marked dirty.\n *\n * Despite the context being updated, nothing has been rendered on screen (not styles or\n * classes have been set on the element). To kick off rendering for an element the following\n * function needs to be run `stylingApply`.\n *\n * `stylingApply` will run through the context and find each dirty value and render them onto\n * the element. Once complete, all styles/classes will be set to clean. Because of this, the render\n * function will now know not to rerun itself again if called again unless new style/class values\n * have changed.\n *\n * ## Directives\n * Directive style/class values (which are provided through host bindings) are also supported and\n * housed within the same styling context as are template-level style/class properties/bindings\n * So long as they are all assigned to the same element, both directive-level and template-level\n * styling bindings share the same context.\n *\n * Each of the following instructions supports accepting a directive instance as an input parameter:\n *\n * - `elementHostAttrs`\n * - `styling`\n * - `styleProp`\n * - `classProp`\n * - `styleMap`\n * - `classMap`\n * - `stylingApply`\n *\n * Each time a directive value is passed in, it will be converted into an index by examining the\n * directive registry (which lives in the context configuration area). The index is then used\n * to help single style properties figure out where a value is located in the context.\n *\n *\n * ## Single-level styling bindings (`[style.prop]` and `[class.name]`)\n *\n * Both `[style.prop]` and `[class.name]` bindings are run through the `updateStyleProp`\n * and `updateClassProp` functions respectively. They work by examining the provided\n * `offset` value and are able to locate the exact spot in the context where the\n * matching style is located.\n *\n * Both `[style.prop]` and `[class.name]` bindings are able to process these values\n * from directive host bindings. When evaluated (from the host binding function) the\n * `directiveRef` value is then passed in.\n *\n * If two directives or a directive + a template binding both write to the same style/class\n * binding then the styling context code will decide which one wins based on the following\n * rule:\n *\n * 1. If the template binding has a value then it always wins\n * 2. Otherwise whichever first-registered directive that has that value first will win\n *\n * The code example helps make this clear:\n *\n * ```\n * <!--\n * <div [style.width]=\"myWidth\"\n *      [my-width-directive]=\"'600px'\">\n * -->\n *\n * @Directive({\n *  selector: '[my-width-directive']\n * })\n * class MyWidthDirective {\n *   @Input('my-width-directive')\n *   @HostBinding('style.width')\n *   public width = null;\n * }\n * ```\n *\n * Since there is a style binding for width present on the element (`[style.width]`) then\n * it will always win over the width binding that is present as a host binding within\n * the `MyWidthDirective`. However, if `[style.width]` renders as `null` (so `myWidth=null`)\n * then the `MyWidthDirective` will be able to write to the `width` style within the context.\n * Simply put, whichever directive writes to a value first ends up having ownership of it as\n * long as the template didn't set anything.\n *\n * The way in which the ownership is facilitated is through index value. The earliest directives\n * get the smallest index values (with 0 being reserved for the template element bindings). Each\n * time a value is written from a directive or the template bindings, the value itself gets\n * assigned the directive index value in its data. If another directive writes a value again then\n * its directive index gets compared against the directive index that exists on the element. Only\n * when the new value's directive index is less than the existing directive index then the new\n * value will be written to the context. But, if the existing value is null then the new value is\n * written by the less important directive.\n *\n * Each directive also has its own sanitizer and dirty flags. These values are consumed within the\n * rendering function.\n *\n *\n * ## Multi-level styling bindings (`[style]` and `[class]`)\n *\n * Multi-level styling bindings are treated as less important (less specific) as single-level\n * bindings (things like `[style.prop]` and `[class.name]`).\n *\n * Multi-level bindings are still applied to the context in a similar way as are single level\n * bindings, but this process works by diffing the new multi-level values (which are key/value\n * maps) against the existing set of styles that live in the context. Each time a new map value\n * is detected (via identity check) then it will loop through the values and figure out what\n * has changed and reorder the context array to match the ordering of the keys. This reordering\n * of the context makes sure that follow-up traversals of the context when updated against the\n * key/value map are as close as possible to o(n) (where \"n\" is the size of the key/value map).\n *\n * If a `directiveRef` value is passed in then the styling algorithm code will take the directive's\n * prioritization index into account and update the values with respect to more important\n * directives. This means that if a value such as `width` is updated in two different `[style]`\n * bindings (say one on the template and another within a directive that sits on the same element)\n * then the algorithm will decide how to update the value based on the following heuristic:\n *\n * 1. If the template binding has a value then it always wins\n * 2. If not then whichever first-registered directive that has that value first will win\n *\n * It will also update the value if it was set to `null` by a previous directive (or the template).\n *\n * Each time a value is updated (or removed) then the context will change shape to better match\n * the ordering of the styling data as well as the ordering of each directive that contains styling\n * data. (See `patchStylingMapIntoContext` inside of class_and_style_bindings.ts to better\n * understand how this works.)\n *\n * ## Rendering\n * The rendering mechanism (when the styling data is applied on screen) occurs via the\n * `stylingApply` function and is designed to run after **all** styling functions have been\n * evaluated. The rendering algorithm will loop over the context and only apply the styles that are\n * flagged as dirty (either because they are new, updated or have been removed via multi or\n * single bindings).\n */\nexport interface StylingContext extends\n    Array<{[key: string]: any}|number|string|boolean|RElement|StyleSanitizeFn|PlayerContext|null> {\n  /**\n   * Location of element that is used as a target for this context.\n   */\n  [StylingIndex.ElementPosition]: LContainer|LView|RElement|null;\n\n  /**\n   * A numeric value representing the configuration status (whether the context is dirty or not)\n   * mixed together (using bit shifting) with a index value which tells the starting index value\n   * of where the multi style entries begin.\n   */\n  [StylingIndex.MasterFlagPosition]: number;\n\n  /**\n   * Location of the collection of directives for this context\n   */\n  [StylingIndex.DirectiveRegistryPosition]: DirectiveRegistryValues;\n\n  /**\n   * Location of all static styles values\n   */\n  [StylingIndex.InitialStyleValuesPosition]: InitialStylingValues;\n\n  /**\n   * Location of all static class values\n   */\n  [StylingIndex.InitialClassValuesPosition]: InitialStylingValues;\n\n  /**\n   * A numeric value representing the class index offset value. Whenever a single class is\n   * applied (using `classProp`) it should have an styling index value that doesn't\n   * need to take into account any style values that exist in the context.\n   */\n  [StylingIndex.SinglePropOffsetPositions]: SinglePropOffsetValues;\n\n  /**\n   * The last class value that was interpreted by `styleMap`. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.CachedMultiClasses]: any|MapBasedOffsetValues;\n\n  /**\n   * The last style value that was interpreted by `classMap`. This is cached\n   * So that the algorithm can exit early incase the value has not changed.\n   */\n  [StylingIndex.CachedMultiStyles]: any|MapBasedOffsetValues;\n\n  /**\n   * A queue of all hostStyling instructions.\n   *\n   * This array (queue) is populated only when host-level styling instructions\n   * (e.g. `hostStyleMap` and `hostClassProp`) are used to apply style and\n   * class values via host bindings to the host element. Despite these being\n   * standard angular instructions, they are not designed to immediately apply\n   * their values to the styling context when executed. What happens instead is\n   * a queue is constructed and each instruction is populated into the queue.\n   * Then, once the style/class values are set to flush (via `stylingApply` or\n   * `hostStylingApply`), the queue is flushed and the values are rendered onto\n   * the host element.\n   */\n  [StylingIndex.HostInstructionsQueue]: HostInstructionsQueue|null;\n\n  /**\n   * Location of animation context (which contains the active players) for this element styling\n   * context.\n   */\n  [StylingIndex.PlayerContext]: PlayerContext|null;\n}\n\n/**\n * A queue of all host-related styling instructions (these are buffered and evaluated just before\n * the styling is applied).\n *\n * This queue is used when any `hostStyling` instructions are executed from the `hostBindings`\n * function. Template-level styling functions (e.g. `styleMap` and `classProp`)\n * do not make use of this queue (they are applied to the styling context immediately).\n *\n * Due to the nature of how components/directives are evaluated, directives (both parent and\n * subclass directives) may not apply their styling at the right time for the styling\n * algorithm code to prioritize them. Therefore, all host-styling instructions are queued up\n * (buffered) into the array below and are automatically sorted in terms of priority. The\n * priority for host-styling is as follows:\n *\n * 1. The template (this doesn't get queued, but gets evaluated immediately)\n * 2. Any directives present on the host\n *   2a) first child directive styling bindings are updated\n *   2b) then any parent directives\n * 3. Component host bindings\n *\n * Angular runs change detection for each of these cases in a different order. Because of this\n * the array below is populated with each of the host styling functions + their arguments.\n *\n * context[HostInstructionsQueue] = [\n *   directiveIndex,\n *   hostStylingFn,\n *   [argumentsForFn],\n *   ...\n *   anotherDirectiveIndex, <-- this has a lower priority (a higher directive index)\n *   anotherHostStylingFn,\n *   [argumentsForFn],\n * ]\n *\n * When `renderStyling` is called (within `class_and_host_bindings.ts`) then the queue is\n * drained and each of the instructions are executed. Once complete the queue is empty then\n * the style/class binding code is rendered on the element (which is what happens normally\n * inside of `renderStyling`).\n *\n * Right now each directive's hostBindings function, as well the template function, both\n * call `stylingApply()` and `hostStylingApply()`. The fact that this is called\n * multiple times for the same element (b/c of change detection) causes some issues. To avoid\n * having styling code be rendered on an element multiple times, the `HostInstructionsQueue`\n * reserves a slot for a reference pointing to the very last directive that was registered and\n * only allows for styling to be applied once that directive is encountered (which will happen\n * as the last update for that element).\n */\nexport interface HostInstructionsQueue extends Array<number|Function|any[]> { [0]: number; }\n\n/**\n * Used as a reference for any values contained within `HostInstructionsQueue`.\n */\nexport const enum HostInstructionsQueueIndex {\n  LastRegisteredDirectiveIndexPosition = 0,\n  ValuesStartPosition = 1,\n  DirectiveIndexOffset = 0,\n  InstructionFnOffset = 1,\n  ParamsOffset = 2,\n  Size = 3,\n}\n\n/**\n * Used as a styling array to house static class and style values that were extracted\n * by the compiler and placed in the animation context via `elementStart` and\n * `elementHostAttrs`.\n *\n * See [InitialStylingValuesIndex] for a breakdown of how all this works.\n */\nexport interface InitialStylingValues extends Array<string|boolean|number|null> {\n  [InitialStylingValuesIndex.DefaultNullValuePosition]: null;\n  [InitialStylingValuesIndex.CachedStringValuePosition]: string|null;\n}\n\n/**\n * Used as an offset/position index to figure out where initial styling\n * values are located.\n *\n * Used as a reference point to provide markers to all static styling\n * values (the initial style and class values on an element) within an\n * array within the `StylingContext`. This array contains key/value pairs\n * where the key is the style property name or className and the value is\n * the style value or whether or not a class is present on the elment.\n *\n * The first value is always null so that a initial index value of\n * `0` will always point to a null value.\n *\n * The second value is also always null unless a string-based representation\n * of the styling data was constructed (it gets cached in this slot).\n *\n * If a <div> elements contains a list of static styling values like so:\n *\n * <div class=\"foo bar baz\" style=\"width:100px; height:200px;\">\n *\n * Then the initial styles for that will look like so:\n *\n * Styles:\n * ```\n * StylingContext[InitialStylesIndex] = [\n *   null, null, 'width', '100px', height, '200px'\n * ]\n * ```\n *\n * Classes:\n * ```\n * StylingContext[InitialClassesIndex] = [\n *   null, null, 'foo', true, 'bar', true, 'baz', true\n * ]\n * ```\n *\n * Initial style and class entries have their own arrays. This is because\n * it's easier to add to the end of one array and not then have to update\n * every context entries' pointer index to the newly offseted values.\n *\n * When property bindinds are added to a context then initial style/class\n * values will also be inserted into the array. This is to create a space\n * in the situation when a follow-up directive inserts static styling into\n * the array. By default, style values are `null` and class values are\n * `false` when inserted by property bindings.\n *\n * For example:\n * ```\n * <div class=\"foo bar baz\"\n *      [class.car]=\"myCarExp\"\n *      style=\"width:100px; height:200px;\"\n *      [style.opacity]=\"myOpacityExp\">\n * ```\n *\n * Will construct initial styling values that look like:\n *\n * Styles:\n * ```\n * StylingContext[InitialStylesIndex] = [\n *   null, null, 'width', '100px', height, '200px', 'opacity', null\n * ]\n * ```\n *\n * Classes:\n * ```\n * StylingContext[InitialClassesIndex] = [\n *   null, null, 'foo', true, 'bar', true, 'baz', true, 'car', false\n * ]\n * ```\n *\n * Now if a directive comes along and introduces `car` as a static\n * class value or `opacity` then those values will be filled into\n * the initial styles array.\n *\n * For example:\n *\n * ```\n * @Directive({\n *   selector: 'opacity-car-directive',\n *   host: {\n *     'style': 'opacity:0.5',\n *     'class': 'car'\n *   }\n * })\n * class OpacityCarDirective {}\n * ```\n *\n * This will render itself as:\n *\n * Styles:\n * ```\n * StylingContext[InitialStylesIndex] = [\n *   null, null, 'width', '100px', height, '200px', 'opacity', '0.5'\n * ]\n * ```\n *\n * Classes:\n * ```\n * StylingContext[InitialClassesIndex] = [\n *   null, null, 'foo', true, 'bar', true, 'baz', true, 'car', true\n * ]\n * ```\n */\nexport const enum InitialStylingValuesIndex {\n  /**\n   * The first value is always `null` so that `styles[0] == null` for unassigned values\n   */\n  DefaultNullValuePosition = 0,\n\n  /**\n   * Used for non-styling code to examine what the style or className string is:\n   * styles: ['width', '100px', 0, 'opacity', null, 0, 'height', '200px', 0]\n   *    => initialStyles[CachedStringValuePosition] = 'width:100px;height:200px';\n   * classes: ['foo', true, 0, 'bar', false, 0, 'baz', true, 0]\n   *    => initialClasses[CachedStringValuePosition] = 'foo bar';\n   *\n   * Note that this value is `null` by default and it will only be populated\n   * once `getInitialStyleStringValue` or `getInitialClassNameValue` is executed.\n   */\n  CachedStringValuePosition = 1,\n\n  /**\n   * Where the style or class values start in the tuple\n   */\n  KeyValueStartPosition = 2,\n\n  /**\n   * The offset value (index + offset) for the property value for each style/class entry\n   */\n  PropOffset = 0,\n\n  /**\n   * The offset value (index + offset) for the style/class value for each style/class entry\n   */\n  ValueOffset = 1,\n\n  /**\n   * The offset value (index + offset) for the style/class directive owner for each style/class\n     entry\n   */\n  DirectiveOwnerOffset = 2,\n\n  /**\n   * The first bit set aside to mark if the initial style was already rendere\n   */\n  AppliedFlagBitPosition = 0b0,\n  AppliedFlagBitLength = 1,\n\n  /**\n   * The total size for each style/class entry (prop + value + directiveOwner)\n   */\n  Size = 3\n}\n\n/**\n * An array located in the StylingContext that houses all directive instances and additional\n * data about them.\n *\n * Each entry in this array represents a source of where style/class binding values could\n * come from. By default, there is always at least one directive here with a null value and\n * that represents bindings that live directly on an element in the template (not host bindings).\n *\n * Each successive entry in the array is an actual instance of a directive as well as some\n * additional info about that entry.\n *\n * An entry within this array has the following values:\n * [0] = The instance of the directive (the first entry is null because its reserved for the\n *       template)\n * [1] = The pointer that tells where the single styling (stuff like [class.foo] and [style.prop])\n *       offset values are located. This value will allow for a binding instruction to find exactly\n *       where a style is located.\n * [2] = Whether or not the directive has any styling values that are dirty. This is used as\n *       reference within the `renderStyling` function to decide whether to skip iterating\n *       through the context when rendering is executed.\n * [3] = The styleSanitizer instance that is assigned to the directive. Although it's unlikely,\n *       a directive could introduce its own special style sanitizer and for this reach each\n *       directive will get its own space for it (if null then the very first sanitizer is used).\n *\n * Each time a new directive is added it will insert these four values at the end of the array.\n * When this array is examined then the resulting directiveIndex will be resolved by dividing the\n * index value by the size of the array entries (so if DirA is at spot 8 then its index will be 2).\n */\nexport interface DirectiveRegistryValues extends Array<null|{}|boolean|number|StyleSanitizeFn> {\n  [DirectiveRegistryValuesIndex.SinglePropValuesIndexOffset]: number;\n  [DirectiveRegistryValuesIndex.StyleSanitizerOffset]: StyleSanitizeFn|null;\n}\n\n/**\n * An enum that outlines the offset/position values for each directive entry and its data\n * that are housed inside of [DirectiveRegistryValues].\n */\nexport const enum DirectiveRegistryValuesIndex {\n  SinglePropValuesIndexOffset = 0,\n  StyleSanitizerOffset = 1,\n  Size = 2\n}\n\n/**\n * An array that contains the index pointer values for every single styling property\n * that exists in the context and for every directive. It also contains the total\n * single styles and single classes that exists in the context as the first two values.\n *\n * Let's say we have the following template code:\n *\n * <div [style.width]=\"myWidth\"\n *      [style.height]=\"myHeight\"\n *      [class.flipped]=\"flipClass\"\n *      directive-with-opacity>\n *      directive-with-foo-bar-classes>\n *\n * We have two directive and template-binding sources,\n * 2 + 1 styles and 1 + 1 classes. When the bindings are\n * registered the SinglePropOffsets array will look like so:\n *\n * s_0/c_0 = template directive value\n * s_1/c_1 = directive one (directive-with-opacity)\n * s_2/c_2 = directive two (directive-with-foo-bar-classes)\n *\n * [3, 2, 2, 1, s_00, s01, c_01, 1, 0, s_10, 0, 1, c_20\n */\nexport interface SinglePropOffsetValues extends Array<number> {\n  [SinglePropOffsetValuesIndex.StylesCountPosition]: number;\n  [SinglePropOffsetValuesIndex.ClassesCountPosition]: number;\n}\n\n/**\n * An enum that outlines the offset/position values for each single prop/class entry\n * that are housed inside of [SinglePropOffsetValues].\n */\nexport const enum SinglePropOffsetValuesIndex {\n  StylesCountPosition = 0,\n  ClassesCountPosition = 1,\n  ValueStartPosition = 2\n}\n\n/**\n * Used a reference for all multi styling values (values that are assigned via the\n * `[style]` and `[class]` bindings).\n *\n * Single-styling properties (things set via `[style.prop]` and `[class.name]` bindings)\n * are not handled using the same approach as multi-styling bindings (such as `[style]`\n * `[class]` bindings).\n *\n * Multi-styling bindings rely on a diffing algorithm to figure out what properties have been added,\n * removed and modified. Multi-styling properties are also evaluated across directives--which means\n * that Angular supports having multiple directives all write to the same `[style]` and `[class]`\n * bindings (using host bindings) even if the `[style]` and/or `[class]` bindings are being written\n * to on the template element.\n *\n * All multi-styling values that are written to an element (whether it be from the template or any\n * directives attached to the element) are all written into the `MapBasedOffsetValues` array. (Note\n * that there are two arrays: one for styles and another for classes.)\n *\n * This array is shaped in the following way:\n *\n * [0]  = The total amount of unique multi-style or multi-class entries that exist currently in the\n *        context.\n * [1+] = Contains an entry of four values ... Each entry is a value assigned by a\n * `[style]`/`[class]`\n *        binding (we call this a **source**).\n *\n *        An example entry looks like so (at a given `i` index):\n *        [i + 0] = Whether or not the value is dirty\n *\n *        [i + 1] = The index of where the map-based values\n *                  (for this **source**) start within the context\n *\n *        [i + 2] = The untouched, last set value of the binding\n *\n *        [i + 3] = The total amount of unqiue binding values that were\n *                  extracted and set into the context. (Note that this value does\n *                  not reflect the total amount of values within the binding\n *                  value (since it's a map), but instead reflects the total values\n *                  that were not used by another directive).\n *\n * Each time a directive (or template) writes a value to a `[class]`/`[style]` binding then the\n * styling diffing algorithm code will decide whether or not to update the value based on the\n * following rules:\n *\n * 1. If a more important directive (either the template or a directive that was registered\n *    beforehand) has written a specific styling value into the context then any follow-up styling\n *    values (set by another directive via its `[style]` and/or `[class]` host binding) will not be\n *    able to set it. This is because the former directive has priorty.\n * 2. Only if a former directive has set a specific styling value to null (whether by actually\n *    setting it to null or not including it in is map value) then a less imporatant directive can\n *    set its own value.\n *\n * ## How the map-based styling algorithm updates itself\n */\nexport interface MapBasedOffsetValues extends Array<any> {\n  [MapBasedOffsetValuesIndex.EntriesCountPosition]: number;\n}\n\nexport const enum MapBasedOffsetValuesIndex {\n  EntriesCountPosition = 0,\n  ValuesStartPosition = 1,\n  DirtyFlagOffset = 0,\n  PositionStartOffset = 1,\n  ValueOffset = 2,\n  ValueCountOffset = 3,\n  Size = 4\n}\n\n/**\n * Used to set the context to be dirty or not both on the master flag (position 1)\n * or for each single/multi property that exists in the context.\n */\nexport const enum StylingFlags {\n  // Implies no configurations\n  None = 0b00000,\n  // Whether or not the entry or context itself is dirty\n  Dirty = 0b00001,\n  // Whether or not this is a class-based assignment\n  Class = 0b00010,\n  // Whether or not a sanitizer was applied to this property\n  Sanitize = 0b00100,\n  // Whether or not any player builders within need to produce new players\n  PlayerBuildersDirty = 0b01000,\n  // The max amount of bits used to represent these configuration values\n  BindingAllocationLocked = 0b10000,\n  BitCountSize = 5,\n  // There are only five bits here\n  BitMask = 0b11111\n}\n\n/** Used as numeric pointer values to determine what cells to update in the `StylingContext` */\nexport const enum StylingIndex {\n  // Position of where the initial styles are stored in the styling context\n  // This index must align with HOST, see interfaces/view.ts\n  ElementPosition = 0,\n  // Index of location where the start of single properties are stored. (`updateStyleProp`)\n  MasterFlagPosition = 1,\n  // Position of where the registered directives exist for this styling context\n  DirectiveRegistryPosition = 2,\n  // Position of where the initial styles are stored in the styling context\n  InitialStyleValuesPosition = 3,\n  InitialClassValuesPosition = 4,\n  // Index of location where the class index offset value is located\n  SinglePropOffsetPositions = 5,\n  // Position of where the last string-based CSS class value was stored (or a cached version of the\n  // initial styles when a [class] directive is present)\n  CachedMultiClasses = 6,\n  // Position of where the last string-based CSS class value was stored\n  CachedMultiStyles = 7,\n  // Multi and single entries are stored in `StylingContext` as: Flag; PropertyName;  PropertyValue\n  // Position of where the initial styles are stored in the styling context\n  HostInstructionsQueue = 8,\n  PlayerContext = 9,\n  // Location of single (prop) value entries are stored within the context\n  SingleStylesStartPosition = 10,\n  FlagsOffset = 0,\n  PropertyOffset = 1,\n  ValueOffset = 2,\n  PlayerBuilderIndexOffset = 3,\n  // Size of each multi or single entry (flag + prop + value + playerBuilderIndex)\n  Size = 4,\n  // Each flag has a binary digit length of this value\n  BitCountSize = 14,  // (32 - 4) / 2 = ~14\n  // The binary digit value as a mask\n  BitMask = 0b11111111111111,  // 14 bits\n}\n\n/**\n * An enum that outlines the bit flag data for directive owner and player index\n * values that exist within en entry that lives in the StylingContext.\n *\n * The values here split a number value into two sets of bits:\n *  - The first 16 bits are used to store the directiveIndex that owns this style value\n *  - The other 16 bits are used to store the playerBuilderIndex that is attached to this style\n */\nexport const enum DirectiveOwnerAndPlayerBuilderIndex {\n  BitCountSize = 16,\n  BitMask = 0b1111111111111111\n}\n\n/**\n * The default directive styling index value for template-based bindings.\n *\n * All host-level bindings (e.g. `hostStyleProp` and `hostClassMap`) are\n * assigned a directive styling index value based on the current directive\n * uniqueId and the directive super-class inheritance depth. But for template\n * bindings they always have the same directive styling index value.\n */\nexport const DEFAULT_TEMPLATE_DIRECTIVE_INDEX = 0;\n"]}