@angular/core 7.2.0-beta.0 → 7.2.0

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

@@ -1,126 +1,331 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * The styling context acts as a styling manifest (shaped as an array) for determining which
  * styling properties have been assigned via the provided `updateStylingMap`, `updateStyleProp`
- * and `updateClassProp` functions. There are also two initialization functions
- * `allocStylingContext` and `createStylingContextTemplate` which are used to initialize
- * and/or clone the context.
+ * and `updateClassProp` functions. It also stores the static style/class values that were
+ * extracted from the template by the compiler.
  *
- * The context is an array where the first two cells are used for static data (initial styling)
- * and dirty flags / index offsets). The remaining set of cells is used for multi (map) and single
- * (prop) style values.
+ * A context is created by Angular when:
+ * 1. An element contains static styling values (like style="..." or class="...")
+ * 2. An element contains single property binding values (like [style.prop]="x" or
+ * [class.prop]="y")
+ * 3. An element contains multi property binding values (like [style]="x" or [class]="y")
+ * 4. A directive contains host bindings for static, single or multi styling properties/bindings.
+ * 5. An animation player is added to an element via `addPlayer`
  *
- * each value from here onwards is mapped as so:
- * [i] = mutation/type flag for the style/class value
- * [i + 1] = prop string (or null incase it has been removed)
- * [i + 2] = value string (or null incase it has been removed)
+ * Note that even if an element contains static styling then this context will be created and
+ * attached to it. The reason why this happens (instead of treating styles/classes as regular
+ * HTML attributes) is because the style/class bindings must be able to default themselves back
+ * to their respective static values when they are set to null.
  *
- * There are three types of styling types stored in this context:
- *   initial: any styles that are passed in once the context is created
- *            (these are stored in the first cell of the array and the first
- *             value of this array is always `null` even if no initial styling exists.
- *             the `null` value is there so that any new styles have a parent to point
- *             to. This way we can always assume that there is a parent.)
+ * Say for example we have this:
+ * ```
+ * <!-- when myWidthExp=null then a width of "100px"
+ *      will be used a default value for width -->
+ * <div style="width:100px" [style.width]="myWidthExp"></div>
+ * ```
+ *
+ * Even in the situation where there are no bindings, the static styling is still placed into the
+ * context because there may be another directive on the same element that has styling.
  *
- *   single: any styles that are updated using `updateStyleProp` or `updateClassProp` (fixed set)
+ * When Angular initializes styling data for an element then it will first register the static
+ * styling values on the element using one of these two instructions:
  *
- *   multi: any styles that are updated using `updateStylingMap` (dynamic set)
+ * 1. elementStart or element (within the template function of a component)
+ * 2. elementHostAttrs (for directive host bindings)
  *
- * Note that context is only used to collect style information. Only when `renderStyling`
- * is called is when the styling payload will be rendered (or built as a key/value map).
+ * In either case, a styling context will be created and stored within an element's LViewData. Once
+ * the styling context is created then single and multi properties can stored within it. For this to
+ * happen, the following function needs to be called:
  *
- * When the context is created, depending on what initial styling values are passed in, the
- * context itself will be pre-filled with slots based on the initial style properties. Say
- * for example we have a series of initial styles that look like so:
+ * `elementStyling` (called with style properties, class properties and a sanitizer + a directive
+ * instance).
  *
- *   style="width:100px; height:200px;"
- *   class="foo"
+ * When this instruction is called it will populate the styling context with the provided style
+ * and class names into the context.
  *
- * Then the initial state of the context (once initialized) will look like so:
+ * The context itself looks like this:
+ *
+ * context = [
+ *   // 0-8: header values (about 8 entries of configuration data)
+ *   // 9+: this is where each entry is stored:
+ * ]
+ *
+ * Let's say we have the following template code:
  *
  * ```
+ * <div class="foo bar"
+ *      style="width:200px; color:red"
+ *      [style.width]="myWidthExp"
+ *      [style.height]="myHeightExp"
+ *      [class.baz]="myBazExp">
+ * ```
+ *
+ * The context generated from these values will look like this (note that
+ * for each binding name (the class and style bindings) the values will
+ * be inserted twice into the array (once for single property entries) and
+ * another for multi property entries).
+ *
  * context = [
- *   element,
- *   playerContext | null,
- *   styleSanitizer | null,
- *   [null, '100px', '200px', true],  // property names are not needed since they have already been
- * written to DOM.
- *
- *   configMasterVal,
- *   1, // this instructs how many `style` values there are so that class index values can be
- * offsetted
- *   { classOne: true, classTwo: false } | 'classOne classTwo' | null // last class value provided
- * into updateStylingMap
- *   { styleOne: '100px', styleTwo: 0 } | null // last style value provided into updateStylingMap
- *
- *   // 8
- *   'width',
- *   pointers(1, 15);  // Point to static `width`: `100px` and multi `width`.
- *   null,
- *
- *   // 11
- *   'height',
- *   pointers(2, 18); // Point to static `height`: `200px` and multi `height`.
- *   null,
- *
- *   // 14
- *   'foo',
- *   pointers(1, 21);  // Point to static `foo`: `true` and multi `foo`.
- *   null,
- *
- *   // 17
- *   'width',
- *   pointers(1, 6);  // Point to static `width`: `100px` and single `width`.
- *   null,
- *
- *   // 21
- *   'height',
- *   pointers(2, 9);  // Point to static `height`: `200px` and single `height`.
- *   null,
- *
- *   // 24
- *   'foo',
- *   pointers(3, 12);  // Point to static `foo`: `true` and single `foo`.
- *   null,
+ *   // 0-8: header values (about 8 entries of configuration data)
+ *   // 9+: this is where each entry is stored:
+ *
+ *   // SINGLE PROPERTIES
+ *   configForWidth,
+ *   'width'
+ *   myWidthExp, // the binding value not the binding itself
+ *   0, // the directive owner
+ *
+ *   configForHeight,
+ *   'height'
+ *   myHeightExp, // the binding value not the binding itself
+ *   0, // the directive owner
+ *
+ *   configForBazClass,
+ *   'baz
+ *   myBazClassExp, // the binding value not the binding itself
+ *   0, // the directive owner
+ *
+ *   // MULTI PROPERTIES
+ *   configForWidth,
+ *   'width'
+ *   myWidthExp, // the binding value not the binding itself
+ *   0, // the directive owner
+ *
+ *   configForHeight,
+ *   'height'
+ *   myHeightExp, // the binding value not the binding itself
+ *   0, // the directive owner
+ *
+ *   configForBazClass,
+ *   'baz
+ *   myBazClassExp, // the binding value not the binding itself
+ *   0, // the directive owner
  * ]
  *
- * function pointers(staticIndex: number, dynamicIndex: number) {
- *   // combine the two indices into a single word.
- *   return (staticIndex << StylingFlags.BitCountSize) |
- *     (dynamicIndex << (StylingIndex.BitCountSize + StylingFlags.BitCountSize));
+ * The configuration values are left out of the example above because
+ * the ordering of them could change between code patches. Please read the
+ * documentation below to get a better understand of what the configuration
+ * 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
+ * well.
+ *
+ * If for example `[style.width]` updates to `555px` then its value will be reflected
+ * in the context as so:
+ *
+ * context = [
+ *   // ...
+ *   configForWidth, // this will be marked DIRTY
+ *   'width'
+ *   '555px',
+ *   0,
+ *   //..
+ * ]
+ *
+ * The context and directive data will also be marked dirty.
+ *
+ * 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`.
+ *
+ * `elementStylingApply` 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.
+ *
+ * ## Directives
+ * Directives style values (which are provided through host bindings) are also supported and
+ * housed within the same styling context as are template-level style/class properties/bindings.
+ * Both directive-level and template-level styling bindings share the same context.
+ *
+ * Each of the following instructions supports accepting a directive instance as an input parameter:
+ *
+ * - `elementHostAttrs`
+ * - `elementStyling`
+ * - `elementStyleProp`
+ * - `elementClassProp`
+ * - `elementStylingMap`
+ * - `elementStylingApply`
+ *
+ * Each time a directiveRef 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
+ * to help single style properties figure out where a value is located in the context.
+ *
+ * If two directives or a directive + a template binding both write to the same style/class
+ * binding then the styling context code will decide which one wins based on the following
+ * rule:
+ *
+ * 1. If the template binding has a value then it always wins
+ * 2. If not then whichever first-registered directive that has that value first will win
+ *
+ * The code example helps make this clear:
+ *
+ * ```
+ * <div [style.width]="myWidth" [my-width-directive]="'600px">
+ * \@Directive({ selector: '[my-width-directive' ]})
+ * class MyWidthDirective {
+ * \@Input('my-width-directive')
+ * \@HostBinding('style.width')
+ *   public width = null;
  * }
  * ```
  *
- * The values are duplicated so that space is set aside for both multi ([style] and [class])
- * and single ([style.prop] or [class.named]) values. The respective config values
- * (configValA, configValB, etc...) are a combination of the StylingFlags with two index
- * values: the `initialIndex` (which points to the index location of the style value in
- * the initial styles array in slot 0) and the `dynamicIndex` (which points to the
- * matching single/multi index position in the context array for the same prop).
- *
- * This means that every time `updateStyleProp` or `updateClassProp` are called then they
- * must be called using an index value (not a property string) which references the index
- * value of the initial style prop/class when the context was created. This also means that
- * `updateStyleProp` or `updateClassProp` cannot be called with a new property (only
- * `updateStylingMap` can include new CSS properties that will be added to the context).
+ * Since there is a style binding for width present on the element (`[style.width]`) then
+ * it will always win over the width binding that is present as a host binding within
+ * the `MyWidthDirective`. However, if `[style.width]` renders as `null` (so `myWidth=null`)
+ * then the `MyWidthDirective` will be able to write to the `width` style within the context.
+ * Simply put, whichever directive writes to a value ends up having ownership of it.
+ *
+ * The way in which the ownership is facilitated is through index value. The earliest directives
+ * get the smallest index values (with 0 being reserved for the template element bindings). Each
+ * time a value is written from a directive or the template bindings, the value itself gets
+ * assigned the directive index value in its data. If another directive writes a value again then
+ * its directive index gets compared against the directive index that exists on the element. Only
+ * when the new value's directive index is less than the existing directive index then the new
+ * value will be written to the context.
+ *
+ * Each directive also has its own sanitizer and dirty flags. These values are consumed within the
+ * rendering function.
  * @record
  */
 export function StylingContext() { }
+if (false) {
+    /* Skipping unnamed member:
+    [StylingIndex.MasterFlagPosition]: number;*/
+    /* Skipping unnamed member:
+    [StylingIndex.DirectiveRegistryPosition]: DirectiveRegistryValues;*/
+    /* Skipping unnamed member:
+    [StylingIndex.InitialStyleValuesPosition]: InitialStylingValues;*/
+    /* Skipping unnamed member:
+    [StylingIndex.InitialClassValuesPosition]: InitialStylingValues;*/
+    /* Skipping unnamed member:
+    [StylingIndex.SinglePropOffsetPositions]: SinglePropOffsetValues;*/
+    /* Skipping unnamed member:
+    [StylingIndex.ElementPosition]: RElement|null;*/
+    /* Skipping unnamed member:
+    [StylingIndex.CachedClassValueOrInitialClassString]: {[key: string]: any}|string|(string)[]|null;*/
+    /* Skipping unnamed member:
+    [StylingIndex.CachedStyleValue]: {[key: string]: any}|(string)[]|null;*/
+    /* Skipping unnamed member:
+    [StylingIndex.PlayerContext]: PlayerContext|null;*/
+}
+/**
+ * Used as a styling array to house static class and style values that were extracted
+ * by the compiler and placed in the animation context via `elementStart` and
+ * `elementHostAttrs`.
+ *
+ * See [InitialStylingValuesIndex] for a breakdown of how all this works.
+ * @record
+ */
+export function InitialStylingValues() { }
+if (false) {
+    /* Skipping unnamed member:
+    [0]: null;*/
+}
+/** @enum {number} */
+const InitialStylingValuesIndex = {
+    KeyValueStartPosition: 1,
+    PropOffset: 0,
+    ValueOffset: 1,
+    Size: 2,
+};
+export { InitialStylingValuesIndex };
+/**
+ * An array located in the StylingContext that houses all directive instances and additional
+ * data about them.
+ *
+ * Each entry in this array represents a source of where style/class binding values could
+ * come from. By default, there is always at least one directive here with a null value and
+ * that represents bindings that live directly on an element (not host bindings).
+ *
+ * Each successive entry in the array is an actual instance of an array as well as some
+ * additional info.
+ *
+ * An entry within this array has the following values:
+ * [0] = The instance of the directive (or null when it is not a directive, but a template binding
+ * source)
+ * [1] = The pointer that tells where the single styling (stuff like [class.foo] and [style.prop])
+ *       offset values are located. This value will allow for a binding instruction to find exactly
+ *       where a style is located.
+ * [2] = Whether or not the directive has any styling values that are dirty. This is used as
+ *       reference within the renderClassAndStyleBindings function to decide whether to skip
+ *       iterating through the context when rendering is executed.
+ * [3] = The styleSanitizer instance that is assigned to the directive. Although it's unlikely,
+ *       a directive could introduce its own special style sanitizer and for this reach each
+ *       directive will get its own space for it (if null then the very first sanitizer is used).
+ *
+ * Each time a new directive is added it will insert these four values at the end of the array.
+ * When this array is examined (using indexOf) then the resulting directiveIndex will be resolved
+ * by dividing the index value by the size of the array entries (so if DirA is at spot 8 then its
+ * index will be 2).
+ * @record
+ */
+export function DirectiveRegistryValues() { }
+if (false) {
+    /* Skipping unnamed member:
+    [DirectiveRegistryValuesIndex.DirectiveValueOffset]: null;*/
+    /* Skipping unnamed member:
+    [DirectiveRegistryValuesIndex.SinglePropValuesIndexOffset]: number;*/
+    /* Skipping unnamed member:
+    [DirectiveRegistryValuesIndex.DirtyFlagOffset]: boolean;*/
+    /* Skipping unnamed member:
+    [DirectiveRegistryValuesIndex.StyleSanitizerOffset]: StyleSanitizeFn|null;*/
+}
+/** @enum {number} */
+const DirectiveRegistryValuesIndex = {
+    DirectiveValueOffset: 0,
+    SinglePropValuesIndexOffset: 1,
+    DirtyFlagOffset: 2,
+    StyleSanitizerOffset: 3,
+    Size: 4,
+};
+export { DirectiveRegistryValuesIndex };
 /**
- * The initial styles is populated whether or not there are any initial styles passed into
- * the context during allocation. The 0th value must be null so that index values of `0` within
- * the context flags can always point to a null value safely when nothing is set.
+ * An array that contains the index pointer values for every single styling property
+ * that exists in the context and for every directive. It also contains the total
+ * single styles and single classes that exists in the context as the first two values.
+ *
+ * Let's say we have the following template code:
+ *
+ * <div [style.width]="myWidth"
+ *      [style.height]="myHeight"
+ *      [class.flipped]="flipClass"
+ *      directive-with-opacity>
+ *      directive-with-foo-bar-classes>
  *
- * All other entries in this array are of `string` value and correspond to the values that
- * were extracted from the `style=""` attribute in the HTML code for the provided template.
+ * We have two directive and template-binding sources,
+ * 2 + 1 styles and 1 + 1 classes. When the bindings are
+ * registered the SinglePropOffsets array will look like so:
+ *
+ * s_0/c_0 = template directive value
+ * s_1/c_1 = directive one (directive-with-opacity)
+ * s_2/c_2 = directive two (directive-with-foo-bar-classes)
+ *
+ * [3, 2, 2, 1, s_00, s01, c_01, 1, 0, s_10, 0, 1, c_20
  * @record
  */
-export function InitialStyles() { }
+export function SinglePropOffsetValues() { }
+if (false) {
+    /* Skipping unnamed member:
+    [SinglePropOffsetValuesIndex.StylesCountPosition]: number;*/
+    /* Skipping unnamed member:
+    [SinglePropOffsetValuesIndex.ClassesCountPosition]: number;*/
+}
+/** @enum {number} */
+const SinglePropOffsetValuesIndex = {
+    StylesCountPosition: 0,
+    ClassesCountPosition: 1,
+    ValueStartPosition: 2,
+};
+export { SinglePropOffsetValuesIndex };
 /** @enum {number} */
-var StylingFlags = {
+const StylingFlags = {
     // Implies no configurations
     None: 0,
     // Whether or not the entry or context itself is dirty
@@ -135,34 +340,36 @@ var StylingFlags = {
     // initial classes
     OnlyProcessSingleClasses: 16,
     // The max amount of bits used to represent these configuration values
-    BitCountSize: 5,
-    // There are only five bits here
-    BitMask: 31,
+    BindingAllocationLocked: 32,
+    BitCountSize: 6,
+    // There are only six bits here
+    BitMask: 63,
 };
 export { StylingFlags };
 /** @enum {number} */
-var StylingIndex = {
-    // Position of where the initial styles are stored in the styling context
-    PlayerContext: 0,
-    // Position of where the style sanitizer is stored within the styling context
-    StyleSanitizerPosition: 1,
-    // Position of where the initial styles are stored in the styling context
-    InitialStylesPosition: 2,
+const StylingIndex = {
     // Index of location where the start of single properties are stored. (`updateStyleProp`)
-    MasterFlagPosition: 3,
+    MasterFlagPosition: 0,
+    // Position of where the registered directives exist for this styling context
+    DirectiveRegistryPosition: 1,
+    // Position of where the initial styles are stored in the styling context
+    InitialStyleValuesPosition: 2,
+    InitialClassValuesPosition: 3,
     // Index of location where the class index offset value is located
-    ClassOffsetPosition: 4,
+    SinglePropOffsetPositions: 4,
     // Position of where the initial styles are stored in the styling context
     // This index must align with HOST, see interfaces/view.ts
     ElementPosition: 5,
     // Position of where the last string-based CSS class value was stored (or a cached version of the
     // initial styles when a [class] directive is present)
-    PreviousOrCachedMultiClassValue: 6,
+    CachedClassValueOrInitialClassString: 6,
     // Position of where the last string-based CSS class value was stored
-    PreviousMultiStyleValue: 7,
-    // Location of single (prop) value entries are stored within the context
-    SingleStylesStartPosition: 8,
+    CachedStyleValue: 7,
     // Multi and single entries are stored in `StylingContext` as: Flag; PropertyName;  PropertyValue
+    // Position of where the initial styles are stored in the styling context
+    PlayerContext: 8,
+    // Location of single (prop) value entries are stored within the context
+    SingleStylesStartPosition: 9,
     FlagsOffset: 0,
     PropertyOffset: 1,
     ValueOffset: 2,
@@ -171,10 +378,14 @@ var StylingIndex = {
     Size: 4,
     // Each flag has a binary digit length of this value
     BitCountSize: 14,
-    // (32 - 4) / 2 = ~14
     // The binary digit value as a mask
     BitMask: 16383,
 };
 export { StylingIndex };
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuLE,OAAc;;IAEd,QAAe;;IAEf,QAAe;;IAEf,WAAkB;;IAElB,sBAA6B;;;IAG7B,4BAAkC;;IAElC,eAAgB;;IAEhB,WAAiB;;;;;;IAMjB,gBAAiB;;IAEjB,yBAA0B;;IAE1B,wBAAyB;;IAEzB,qBAAsB;;IAEtB,sBAAuB;;;IAGvB,kBAAmB;;;IAGnB,kCAAmC;;IAEnC,0BAA2B;;IAE3B,4BAA6B;;IAE7B,cAAe;IACf,iBAAkB;IAClB,cAAe;IACf,2BAA4B;;IAE5B,OAAQ;;IAER,gBAAiB;;;IAEjB,cAA0B","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 {PlayerContext} from './player';\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. There are also two initialization functions\n * `allocStylingContext` and `createStylingContextTemplate` which are used to initialize\n * and/or clone the context.\n *\n * The context is an array where the first two cells are used for static data (initial styling)\n * and dirty flags / index offsets). The remaining set of cells is used for multi (map) and single\n * (prop) style values.\n *\n * each value from here onwards is mapped as so:\n * [i] = mutation/type flag for the style/class value\n * [i + 1] = prop string (or null incase it has been removed)\n * [i + 2] = value string (or null incase it has been removed)\n *\n * There are three types of styling types stored in this context:\n *   initial: any styles that are passed in once the context is created\n *            (these are stored in the first cell of the array and the first\n *             value of this array is always `null` even if no initial styling exists.\n *             the `null` value is there so that any new styles have a parent to point\n *             to. This way we can always assume that there is a parent.)\n *\n *   single: any styles that are updated using `updateStyleProp` or `updateClassProp` (fixed set)\n *\n *   multi: any styles that are updated using `updateStylingMap` (dynamic set)\n *\n * Note that context is only used to collect style information. Only when `renderStyling`\n * is called is when the styling payload will be rendered (or built as a key/value map).\n *\n * When the context is created, depending on what initial styling values are passed in, the\n * context itself will be pre-filled with slots based on the initial style properties. Say\n * for example we have a series of initial styles that look like so:\n *\n *   style=\"width:100px; height:200px;\"\n *   class=\"foo\"\n *\n * Then the initial state of the context (once initialized) will look like so:\n *\n * ```\n * context = [\n *   element,\n *   playerContext | null,\n *   styleSanitizer | null,\n *   [null, '100px', '200px', true],  // property names are not needed since they have already been\n * written to DOM.\n *\n *   configMasterVal,\n *   1, // this instructs how many `style` values there are so that class index values can be\n * offsetted\n *   { classOne: true, classTwo: false } | 'classOne classTwo' | null // last class value provided\n * into updateStylingMap\n *   { styleOne: '100px', styleTwo: 0 } | null // last style value provided into updateStylingMap\n *\n *   // 8\n *   'width',\n *   pointers(1, 15);  // Point to static `width`: `100px` and multi `width`.\n *   null,\n *\n *   // 11\n *   'height',\n *   pointers(2, 18); // Point to static `height`: `200px` and multi `height`.\n *   null,\n *\n *   // 14\n *   'foo',\n *   pointers(1, 21);  // Point to static `foo`: `true` and multi `foo`.\n *   null,\n *\n *   // 17\n *   'width',\n *   pointers(1, 6);  // Point to static `width`: `100px` and single `width`.\n *   null,\n *\n *   // 21\n *   'height',\n *   pointers(2, 9);  // Point to static `height`: `200px` and single `height`.\n *   null,\n *\n *   // 24\n *   'foo',\n *   pointers(3, 12);  // Point to static `foo`: `true` and single `foo`.\n *   null,\n * ]\n *\n * function pointers(staticIndex: number, dynamicIndex: number) {\n *   // combine the two indices into a single word.\n *   return (staticIndex << StylingFlags.BitCountSize) |\n *     (dynamicIndex << (StylingIndex.BitCountSize + StylingFlags.BitCountSize));\n * }\n * ```\n *\n * The values are duplicated so that space is set aside for both multi ([style] and [class])\n * and single ([style.prop] or [class.named]) values. The respective config values\n * (configValA, configValB, etc...) are a combination of the StylingFlags with two index\n * values: the `initialIndex` (which points to the index location of the style value in\n * the initial styles array in slot 0) and the `dynamicIndex` (which points to the\n * matching single/multi index position in the context array for the same prop).\n *\n * This means that every time `updateStyleProp` or `updateClassProp` are called then they\n * must be called using an index value (not a property string) which references the index\n * value of the initial style prop/class when the context was created. This also means that\n * `updateStyleProp` or `updateClassProp` cannot be called with a new property (only\n * `updateStylingMap` can include new CSS properties that will be added to the context).\n */\nexport interface StylingContext extends Array<InitialStyles|{[key: string]: any}|number|string|\n                                              boolean|RElement|StyleSanitizeFn|PlayerContext|null> {\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   * The style sanitizer that is used within this context\n   */\n  [StylingIndex.StyleSanitizerPosition]: StyleSanitizeFn|null;\n\n  /**\n   * Location of initial data shared by all instances of this style.\n   */\n  [StylingIndex.InitialStylesPosition]: InitialStyles;\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   * 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.ClassOffsetPosition]: number;\n\n  /**\n   * Location of element that is used as a target for this context.\n   */\n  [StylingIndex.ElementPosition]: RElement|null;\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.PreviousOrCachedMultiClassValue]: {[key: string]: any}|string|null;\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.PreviousMultiStyleValue]: {[key: string]: any}|null;\n}\n\n/**\n * The initial styles is populated whether or not there are any initial styles passed into\n * the context during allocation. The 0th value must be null so that index values of `0` within\n * the context flags can always point to a null value safely when nothing is set.\n *\n * All other entries in this array are of `string` value and correspond to the values that\n * were extracted from the `style=\"\"` attribute in the HTML code for the provided template.\n */\nexport interface InitialStyles extends Array<string|null|boolean> { [0]: null; }\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  // If NgClass is present (or some other class handler) then it will handle the map expressions and\n  // initial classes\n  OnlyProcessSingleClasses = 0b10000,\n  // The max amount of bits used to represent these configuration values\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  PlayerContext = 0,\n  // Position of where the style sanitizer is stored within the styling context\n  StyleSanitizerPosition = 1,\n  // Position of where the initial styles are stored in the styling context\n  InitialStylesPosition = 2,\n  // Index of location where the start of single properties are stored. (`updateStyleProp`)\n  MasterFlagPosition = 3,\n  // Index of location where the class index offset value is located\n  ClassOffsetPosition = 4,\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 = 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  PreviousOrCachedMultiClassValue = 6,\n  // Position of where the last string-based CSS class value was stored\n  PreviousMultiStyleValue = 7,\n  // Location of single (prop) value entries are stored within the context\n  SingleStylesStartPosition = 8,\n  // Multi and single entries are stored in `StylingContext` as: Flag; PropertyName;  PropertyValue\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"]}
+/** @enum {number} */
+const DirectiveOwnerAndPlayerBuilderIndex = {
+    BitCountSize: 16,
+    BitMask: 65535,
+};
+export { DirectiveOwnerAndPlayerBuilderIndex };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0MA,oCAqDC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASD,0CAAuF;;;;;;;IAuFrF,wBAAyB;IACzB,aAAc;IACd,cAAe;IACf,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCV,6CAKC;;;;;;;;;;;;;IAOC,uBAAwB;IACxB,8BAA+B;IAC/B,kBAAmB;IACnB,uBAAwB;IACxB,OAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BV,4CAGC;;;;;;;;;IAOC,sBAAuB;IACvB,uBAAwB;IACxB,qBAAsB;;;;;IAQtB,4BAA4B;IAC5B,OAAe;IACf,sDAAsD;IACtD,QAAgB;IAChB,kDAAkD;IAClD,QAAgB;IAChB,0DAA0D;IAC1D,WAAmB;IACnB,wEAAwE;IACxE,sBAA8B;IAC9B,kGAAkG;IAClG,kBAAkB;IAClB,4BAAmC;IACnC,sEAAsE;IACtE,2BAAkC;IAClC,eAAgB;IAChB,+BAA+B;IAC/B,WAAkB;;;;;IAKlB,yFAAyF;IACzF,qBAAsB;IACtB,6EAA6E;IAC7E,4BAA6B;IAC7B,yEAAyE;IACzE,6BAA8B;IAC9B,6BAA8B;IAC9B,kEAAkE;IAClE,4BAA6B;IAC7B,yEAAyE;IACzE,0DAA0D;IAC1D,kBAAmB;IACnB,iGAAiG;IACjG,sDAAsD;IACtD,uCAAwC;IACxC,qEAAqE;IACrE,mBAAoB;IACpB,iGAAiG;IACjG,yEAAyE;IACzE,gBAAiB;IACjB,wEAAwE;IACxE,4BAA6B;IAC7B,cAAe;IACf,iBAAkB;IAClB,cAAe;IACf,2BAA4B;IAC5B,gFAAgF;IAChF,OAAQ;IACR,oDAAoD;IACpD,gBAAiB;IACjB,mCAAmC;IACnC,cAA0B;;;;;IAY1B,gBAAiB;IACjB,cAA4B","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 {PlayerContext} from './player';\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. Once\n * the styling context is created then single and multi properties can stored within it. For this to\n * 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 * another 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 * Directives style 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 * Both directive-level and template-level 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 directiveRef 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 * 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. If not then whichever first-registered directive that has that value first will win\n *\n * The code example helps make this clear:\n *\n * ```\n * <div [style.width]=\"myWidth\" [my-width-directive]=\"'600px\">\n * @Directive({ selector: '[my-width-directive' ]})\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 ends up having ownership of it.\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.\n *\n * Each directive also has its own sanitizer and dirty flags. These values are consumed within the\n * rendering function.\n */\nexport interface StylingContext extends\n    Array<{[key: string]: any}|number|string|boolean|RElement|StyleSanitizeFn|PlayerContext|null> {\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   * Location of element that is used as a target for this context.\n   */\n  [StylingIndex.ElementPosition]: RElement|null;\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.CachedClassValueOrInitialClassString]: {[key: string]: any}|string|(string)[]|null;\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.CachedStyleValue]: {[key: string]: any}|(string)[]|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 * 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|null> { [0]: null; }\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 also always null so that a initial index value of\n * `0` will always point to a null value.\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 * StylingContext[InitialStylesIndex] = [\n *   null, 'width', '100px', height, '200px'\n * ]\n *\n * Classes:\n * StylingContext[InitialStylesIndex] = [\n *   null, 'foo', true, 'bar', true, 'baz', true\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 * <div class=\"foo bar baz\"\n *      [class.car]=\"myCarExp\"\n *      style=\"width:100px; height:200px;\"\n *      [style.opacity]=\"myOpacityExp\">\n *\n * Will construct initial styling values that look like:\n *\n * Styles:\n * StylingContext[InitialStylesIndex] = [\n *   null, 'width', '100px', height, '200px', 'opacity', null\n * ]\n *\n * Classes:\n * StylingContext[InitialStylesIndex] = [\n *   null, 'foo', true, 'bar', true, 'baz', true, 'car', false\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 * @Directive({\n *   selector: 'opacity-car-directive',\n *   host: {\n *     'style': 'opacity:0.5',\n *     'class': 'car'\n *   }\n * })\n * class OpacityCarDirective {}\n *\n * This will render itself as:\n *\n * Styles:\n * StylingContext[InitialStylesIndex] = [\n *   null, 'width', '100px', height, '200px', 'opacity', null\n * ]\n *\n * Classes:\n * StylingContext[InitialStylesIndex] = [\n *   null, 'foo', true, 'bar', true, 'baz', true, 'car', false\n * ]\n */\nexport const enum InitialStylingValuesIndex {\n  KeyValueStartPosition = 1,\n  PropOffset = 0,\n  ValueOffset = 1,\n  Size = 2\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 (not host bindings).\n *\n * Each successive entry in the array is an actual instance of an array as well as some\n * additional info.\n *\n * An entry within this array has the following values:\n * [0] = The instance of the directive (or null when it is not a directive, but a template binding\n * source)\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 renderClassAndStyleBindings function to decide whether to skip\n *       iterating 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 (using indexOf) then the resulting directiveIndex will be resolved\n * by dividing the index value by the size of the array entries (so if DirA is at spot 8 then its\n * index will be 2).\n */\nexport interface DirectiveRegistryValues extends Array<null|{}|boolean|number|StyleSanitizeFn> {\n  [DirectiveRegistryValuesIndex.DirectiveValueOffset]: null;\n  [DirectiveRegistryValuesIndex.SinglePropValuesIndexOffset]: number;\n  [DirectiveRegistryValuesIndex.DirtyFlagOffset]: boolean;\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  DirectiveValueOffset = 0,\n  SinglePropValuesIndexOffset = 1,\n  DirtyFlagOffset = 2,\n  StyleSanitizerOffset = 3,\n  Size = 4\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 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 = 0b000000,\n  // Whether or not the entry or context itself is dirty\n  Dirty = 0b000001,\n  // Whether or not this is a class-based assignment\n  Class = 0b000010,\n  // Whether or not a sanitizer was applied to this property\n  Sanitize = 0b000100,\n  // Whether or not any player builders within need to produce new players\n  PlayerBuildersDirty = 0b001000,\n  // If NgClass is present (or some other class handler) then it will handle the map expressions and\n  // initial classes\n  OnlyProcessSingleClasses = 0b010000,\n  // The max amount of bits used to represent these configuration values\n  BindingAllocationLocked = 0b100000,\n  BitCountSize = 6,\n  // There are only six bits here\n  BitMask = 0b111111\n}\n\n/** Used as numeric pointer values to determine what cells to update in the `StylingContext` */\nexport const enum StylingIndex {\n  // Index of location where the start of single properties are stored. (`updateStyleProp`)\n  MasterFlagPosition = 0,\n  // Position of where the registered directives exist for this styling context\n  DirectiveRegistryPosition = 1,\n  // Position of where the initial styles are stored in the styling context\n  InitialStyleValuesPosition = 2,\n  InitialClassValuesPosition = 3,\n  // Index of location where the class index offset value is located\n  SinglePropOffsetPositions = 4,\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 = 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  CachedClassValueOrInitialClassString = 6,\n  // Position of where the last string-based CSS class value was stored\n  CachedStyleValue = 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  PlayerContext = 8,\n  // Location of single (prop) value entries are stored within the context\n  SingleStylesStartPosition = 9,\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"]}