@angular/core 7.2.0-beta.0 → 7.2.0

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

@@ -1,167 +1,478 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+import { assertNotEqual } from '../assert';
+import { EMPTY_ARRAY, EMPTY_OBJ } from '../empty';
 import { RendererStyleFlags3, isProceduralRenderer } from '../interfaces/renderer';
 import { NO_CHANGE } from '../tokens';
 import { getRootContext } from '../util';
 import { BoundPlayerFactory } from './player_factory';
 import { addPlayerInternal, allocPlayerContext, createEmptyStylingContext, getPlayerContext } from './util';
-/** @type {?} */
-const EMPTY_ARR = [];
-/** @type {?} */
-const EMPTY_OBJ = {};
-/**
- * Creates a styling context template where styling information is stored.
- * Any styles that are later referenced using `updateStyleProp` must be
- * passed in within this function. Initial values for those styles are to
- * be declared after all initial style properties are declared (this change in
- * mode between declarations and initial styles is made possible using a special
- * enum value found in `definition.ts`).
- *
- * @param {?=} initialClassDeclarations a list of class declarations and initial class values
- *    that are used later within the styling context.
- *
- *    -> ['foo', 'bar', SPECIAL_ENUM_VAL, 'foo', true]
- *       This implies that `foo` and `bar` will be later styled and that the `foo`
- *       class will be applied to the element as an initial class since it's true
- * @param {?=} initialStyleDeclarations a list of style declarations and initial style values
- *    that are used later within the styling context.
+/**
+ * This file includes the code to power all styling-binding operations in Angular.
  *
- *    -> ['width', 'height', SPECIAL_ENUM_VAL, 'width', '100px']
- *       This implies that `width` and `height` will be later styled and that the `width`
- *       property has an initial value of `100px`.
+ * These include:
+ * [style]="myStyleObj"
+ * [class]="myClassObj"
+ * [style.prop]="myPropValue"
+ * [class.name]="myClassValue"
  *
- * @param {?=} styleSanitizer
- * @param {?=} onlyProcessSingleClasses
+ * There are many different ways in which these functions below are called. Please see
+ * `interfaces/styles.ts` to get a better idea of how the styling algorithm works.
+ */
+/**
+ * Creates a new StylingContext an fills it with the provided static styling attribute values.
+ * @param {?} attrs
  * @return {?}
  */
-export function createStylingContextTemplate(initialClassDeclarations, initialStyleDeclarations, styleSanitizer, onlyProcessSingleClasses) {
-    /** @type {?} */
-    const initialStylingValues = [null];
+export function initializeStaticContext(attrs) {
     /** @type {?} */
-    const context = createEmptyStylingContext(null, styleSanitizer, initialStylingValues);
+    const context = createEmptyStylingContext();
     /** @type {?} */
-    const stylesLookup = {};
+    const initialClasses = context[3 /* InitialClassValuesPosition */] =
+        [null];
     /** @type {?} */
-    const classesLookup = {};
+    const initialStyles = context[2 /* InitialStyleValuesPosition */] =
+        [null];
+    // The attributes array has marker values (numbers) indicating what the subsequent
+    // values represent. When we encounter a number, we set the mode to that type of attribute.
     /** @type {?} */
-    let totalStyleDeclarations = 0;
-    if (initialStyleDeclarations) {
+    let mode = -1;
+    for (let i = 0; i < attrs.length; i++) {
         /** @type {?} */
-        let hasPassedDeclarations = false;
-        for (let i = 0; i < initialStyleDeclarations.length; i++) {
+        const attr = attrs[i];
+        if (typeof attr == 'number') {
+            mode = attr;
+        }
+        else if (mode === 2 /* Styles */) {
+            initialStyles.push((/** @type {?} */ (attr)), (/** @type {?} */ (attrs[++i])));
+        }
+        else if (mode === 1 /* Classes */) {
+            initialClasses.push((/** @type {?} */ (attr)), true);
+        }
+        else if (mode === 3 /* SelectOnly */) {
+            break;
+        }
+    }
+    return context;
+}
+/**
+ * Designed to update an existing styling context with new static styling
+ * data (classes and styles).
+ *
+ * @param {?} context the existing styling context
+ * @param {?} attrs an array of new static styling attributes that will be
+ *              assigned to the context
+ * @param {?} directive the directive instance with which static data is associated with.
+ * @return {?}
+ */
+export function patchContextWithStaticAttrs(context, attrs, directive) {
+    // If the styling context has already been patched with the given directive's bindings,
+    // then there is no point in doing it again. The reason why this may happen (the directive
+    // styling being patched twice) is because the `stylingBinding` function is called each time
+    // an element is created (both within a template function and within directive host bindings).
+    /** @type {?} */
+    const directives = context[1 /* DirectiveRegistryPosition */];
+    if (getDirectiveRegistryValuesIndexOf(directives, directive) == -1) {
+        // this is a new directive which we have not seen yet.
+        directives.push(directive, -1, false, null);
+        /** @type {?} */
+        let initialClasses = null;
+        /** @type {?} */
+        let initialStyles = null;
+        /** @type {?} */
+        let mode = -1;
+        for (let i = 0; i < attrs.length; i++) {
             /** @type {?} */
-            const v = /** @type {?} */ (initialStyleDeclarations[i]);
-            // this flag value marks where the declarations end the initial values begin
-            if (v === 1 /* VALUES_MODE */) {
-                hasPassedDeclarations = true;
+            const attr = attrs[i];
+            if (typeof attr == 'number') {
+                mode = attr;
             }
-            else {
-                /** @type {?} */
-                const prop = /** @type {?} */ (v);
-                if (hasPassedDeclarations) {
-                    /** @type {?} */
-                    const value = /** @type {?} */ (initialStyleDeclarations[++i]);
-                    initialStylingValues.push(value);
-                    stylesLookup[prop] = initialStylingValues.length - 1;
-                }
-                else {
-                    totalStyleDeclarations++;
-                    stylesLookup[prop] = 0;
-                }
+            else if (mode == 1 /* Classes */) {
+                initialClasses = initialClasses || context[3 /* InitialClassValuesPosition */];
+                patchInitialStylingValue(initialClasses, attr, true);
+            }
+            else if (mode == 2 /* Styles */) {
+                initialStyles = initialStyles || context[2 /* InitialStyleValuesPosition */];
+                patchInitialStylingValue(initialStyles, attr, attrs[++i]);
             }
         }
     }
-    // make where the class offsets begin
-    context[4 /* ClassOffsetPosition */] = totalStyleDeclarations;
-    /** @type {?} */
-    const initialStaticClasses = onlyProcessSingleClasses ? [] : null;
-    if (initialClassDeclarations) {
+}
+/**
+ * Designed to add a style or class value into the existing set of initial styles.
+ *
+ * The function will search and figure out if a style/class value is already present
+ * within the provided initial styling array. If and when a style/class value is not
+ * present (or if it's value is falsy) then it will be inserted/updated in the list
+ * of initial styling values.
+ * @param {?} initialStyling
+ * @param {?} prop
+ * @param {?} value
+ * @return {?}
+ */
+function patchInitialStylingValue(initialStyling, prop, value) {
+    // Even values are keys; Odd numbers are values; Search keys only
+    for (let i = 1 /* KeyValueStartPosition */; i < initialStyling.length;) {
         /** @type {?} */
-        let hasPassedDeclarations = false;
-        for (let i = 0; i < initialClassDeclarations.length; i++) {
+        const key = initialStyling[i];
+        if (key === prop) {
             /** @type {?} */
-            const v = /** @type {?} */ (initialClassDeclarations[i]);
-            // this flag value marks where the declarations end the initial values begin
-            if (v === 1 /* VALUES_MODE */) {
-                hasPassedDeclarations = true;
+            const existingValue = initialStyling[i + 1 /* ValueOffset */];
+            // If there is no previous style value (when `null`) or no previous class
+            // applied (when `false`) then we update the the newly given value.
+            if (existingValue == null || existingValue == false) {
+                initialStyling[i + 1 /* ValueOffset */] = value;
+            }
+            return;
+        }
+        i = i + 2 /* Size */;
+    }
+    // We did not find existing key, add a new one.
+    initialStyling.push(prop, value);
+}
+/**
+ * Runs through the initial styling data present in the context and renders
+ * them via the renderer on the element.
+ * @param {?} element
+ * @param {?} context
+ * @param {?} renderer
+ * @return {?}
+ */
+export function renderInitialStylesAndClasses(element, context, renderer) {
+    /** @type {?} */
+    const initialClasses = context[3 /* InitialClassValuesPosition */];
+    renderInitialStylingValues(element, renderer, initialClasses, true);
+    /** @type {?} */
+    const initialStyles = context[2 /* InitialStyleValuesPosition */];
+    renderInitialStylingValues(element, renderer, initialStyles, false);
+}
+/**
+ * This is a helper function designed to render each entry present within the
+ * provided list of initialStylingValues.
+ * @param {?} element
+ * @param {?} renderer
+ * @param {?} initialStylingValues
+ * @param {?} isEntryClassBased
+ * @return {?}
+ */
+function renderInitialStylingValues(element, renderer, initialStylingValues, isEntryClassBased) {
+    for (let i = 1 /* KeyValueStartPosition */; i < initialStylingValues.length; i += 2 /* Size */) {
+        /** @type {?} */
+        const value = initialStylingValues[i + 1 /* ValueOffset */];
+        if (value) {
+            if (isEntryClassBased) {
+                setClass(element, (/** @type {?} */ (initialStylingValues[i + 0 /* PropOffset */])), true, renderer, null);
             }
             else {
-                /** @type {?} */
-                const className = /** @type {?} */ (v);
-                if (hasPassedDeclarations) {
-                    /** @type {?} */
-                    const value = /** @type {?} */ (initialClassDeclarations[++i]);
-                    initialStylingValues.push(value);
-                    classesLookup[className] = initialStylingValues.length - 1;
-                    initialStaticClasses && initialStaticClasses.push(className);
-                }
-                else {
-                    classesLookup[className] = 0;
-                }
+                setStyle(element, (/** @type {?} */ (initialStylingValues[i + 0 /* PropOffset */])), (/** @type {?} */ (value)), renderer, null);
             }
         }
     }
+}
+/**
+ * @param {?} context
+ * @return {?}
+ */
+export function allowNewBindingsForStylingContext(context) {
+    return (context[0 /* MasterFlagPosition */] & 32 /* BindingAllocationLocked */) === 0;
+}
+/**
+ * Adds in new binding values to a styling context.
+ *
+ * If a directive value is provided then all provided class/style binding names will
+ * reference the provided directive.
+ *
+ * @param {?} context the existing styling context
+ * @param {?} directiveRef the directive that the new bindings will reference
+ * @param {?=} classBindingNames an array of class binding names that will be added to the context
+ * @param {?=} styleBindingNames an array of style binding names that will be added to the context
+ * @param {?=} styleSanitizer an optional sanitizer that handle all sanitization on for each of
+ *    the bindings added to the context. Note that if a directive is provided then the sanitizer
+ *    instance will only be active if and when the directive updates the bindings that it owns.
+ * @param {?=} onlyProcessSingleClasses
+ * @return {?}
+ */
+export function updateContextWithBindings(context, directiveRef, classBindingNames, styleBindingNames, styleSanitizer, onlyProcessSingleClasses) {
+    if (context[0 /* MasterFlagPosition */] & 32 /* BindingAllocationLocked */)
+        return;
+    // this means the context has already been patched with the directive's bindings
+    /** @type {?} */
+    const directiveIndex = findOrPatchDirectiveIntoRegistry(context, directiveRef, styleSanitizer);
+    if (directiveIndex === -1) {
+        // this means the directive has already been patched in ... No point in doing anything
+        return;
+    }
+    // there are alot of variables being used below to track where in the context the new
+    // binding values will be placed. Because the context consists of multiple types of
+    // entries (single classes/styles and multi classes/styles) alot of the index positions
+    // need to be computed ahead of time and the context needs to be extended before the values
+    // are inserted in.
+    /** @type {?} */
+    const singlePropOffsetValues = context[4 /* SinglePropOffsetPositions */];
+    /** @type {?} */
+    const totalCurrentClassBindings = singlePropOffsetValues[1 /* ClassesCountPosition */];
+    /** @type {?} */
+    const totalCurrentStyleBindings = singlePropOffsetValues[0 /* StylesCountPosition */];
     /** @type {?} */
-    const styleProps = Object.keys(stylesLookup);
+    const classesOffset = totalCurrentClassBindings * 4 /* Size */;
     /** @type {?} */
-    const classNames = Object.keys(classesLookup);
+    const stylesOffset = totalCurrentStyleBindings * 4 /* Size */;
     /** @type {?} */
-    const classNamesIndexStart = styleProps.length;
+    const singleStylesStartIndex = 9 /* SingleStylesStartPosition */;
     /** @type {?} */
-    const totalProps = styleProps.length + classNames.length;
+    let singleClassesStartIndex = singleStylesStartIndex + stylesOffset;
     /** @type {?} */
-    const maxLength = totalProps * 4 /* Size */ * 2 + 8 /* SingleStylesStartPosition */;
-    // we need to fill the array from the start so that we can access
-    // both the multi and the single array positions in the same loop block
-    for (let i = 8 /* SingleStylesStartPosition */; i < maxLength; i++) {
+    let multiStylesStartIndex = singleClassesStartIndex + classesOffset;
+    /** @type {?} */
+    let multiClassesStartIndex = multiStylesStartIndex + stylesOffset;
+    // because we're inserting more bindings into the context, this means that the
+    // binding values need to be referenced the singlePropOffsetValues array so that
+    // the template/directive can easily find them inside of the `elementStyleProp`
+    // and the `elementClassProp` functions without iterating through the entire context.
+    // The first step to setting up these reference points is to mark how many bindings
+    // are being added. Even if these bindings already exist in the context, the directive
+    // or template code will still call them unknowingly. Therefore the total values need
+    // to be registered so that we know how many bindings are assigned to each directive.
+    /** @type {?} */
+    const currentSinglePropsLength = singlePropOffsetValues.length;
+    singlePropOffsetValues.push(styleBindingNames ? styleBindingNames.length : 0, classBindingNames ? classBindingNames.length : 0);
+    // the code below will check to see if a new style binding already exists in the context
+    // if so then there is no point in inserting it into the context again. Whether or not it
+    // exists the styling offset code will now know exactly where it is
+    /** @type {?} */
+    let insertionOffset = 0;
+    /** @type {?} */
+    const filteredStyleBindingNames = [];
+    if (styleBindingNames && styleBindingNames.length) {
+        for (let i = 0; i < styleBindingNames.length; i++) {
+            /** @type {?} */
+            const name = styleBindingNames[i];
+            /** @type {?} */
+            let singlePropIndex = getMatchingBindingIndex(context, name, singleStylesStartIndex, singleClassesStartIndex);
+            if (singlePropIndex == -1) {
+                singlePropIndex = singleClassesStartIndex + insertionOffset;
+                insertionOffset += 4 /* Size */;
+                filteredStyleBindingNames.push(name);
+            }
+            singlePropOffsetValues.push(singlePropIndex);
+        }
+    }
+    // just like with the style binding loop above, the new class bindings get the same treatment...
+    /** @type {?} */
+    const filteredClassBindingNames = [];
+    if (classBindingNames && classBindingNames.length) {
+        for (let i = 0; i < classBindingNames.length; i++) {
+            /** @type {?} */
+            const name = classBindingNames[i];
+            /** @type {?} */
+            let singlePropIndex = getMatchingBindingIndex(context, name, singleClassesStartIndex, multiStylesStartIndex);
+            if (singlePropIndex == -1) {
+                singlePropIndex = multiStylesStartIndex + insertionOffset;
+                insertionOffset += 4 /* Size */;
+                filteredClassBindingNames.push(name);
+            }
+            else {
+                singlePropIndex += filteredStyleBindingNames.length * 4 /* Size */;
+            }
+            singlePropOffsetValues.push(singlePropIndex);
+        }
+    }
+    // because new styles are being inserted, this means the existing collection of style offset
+    // index values are incorrect (they point to the wrong values). The code below will run through
+    // the entire offset array and update the existing set of index values to point to their new
+    // locations while taking the new binding values into consideration.
+    /** @type {?} */
+    let i = 2 /* ValueStartPosition */;
+    if (filteredStyleBindingNames.length) {
+        while (i < currentSinglePropsLength) {
+            /** @type {?} */
+            const totalStyles = singlePropOffsetValues[i + 0 /* StylesCountPosition */];
+            /** @type {?} */
+            const totalClasses = singlePropOffsetValues[i + 1 /* ClassesCountPosition */];
+            if (totalClasses) {
+                /** @type {?} */
+                const start = i + 2 /* ValueStartPosition */ + totalStyles;
+                for (let j = start; j < start + totalClasses; j++) {
+                    singlePropOffsetValues[j] += filteredStyleBindingNames.length * 4 /* Size */;
+                }
+            }
+            /** @type {?} */
+            const total = totalStyles + totalClasses;
+            i += 2 /* ValueStartPosition */ + total;
+        }
+    }
+    /** @type {?} */
+    const totalNewEntries = filteredClassBindingNames.length + filteredStyleBindingNames.length;
+    // in the event that there are new style values being inserted, all existing class and style
+    // bindings need to have their pointer values offsetted with the new amount of space that is
+    // used for the new style/class bindings.
+    for (let i = singleStylesStartIndex; i < context.length; i += 4 /* Size */) {
+        /** @type {?} */
+        const isMultiBased = i >= multiStylesStartIndex;
+        /** @type {?} */
+        const isClassBased = i >= (isMultiBased ? multiClassesStartIndex : singleClassesStartIndex);
+        /** @type {?} */
+        const flag = getPointers(context, i);
+        /** @type {?} */
+        const staticIndex = getInitialIndex(flag);
+        /** @type {?} */
+        let singleOrMultiIndex = getMultiOrSingleIndex(flag);
+        if (isMultiBased) {
+            singleOrMultiIndex +=
+                isClassBased ? (filteredStyleBindingNames.length * 4 /* Size */) : 0;
+        }
+        else {
+            singleOrMultiIndex += (totalNewEntries * 4 /* Size */) +
+                ((isClassBased ? filteredStyleBindingNames.length : 0) * 4 /* Size */);
+        }
+        setFlag(context, i, pointers(flag, staticIndex, singleOrMultiIndex));
+    }
+    // this is where we make space in the context for the new style bindings
+    for (let i = 0; i < filteredStyleBindingNames.length * 4 /* Size */; i++) {
+        context.splice(multiClassesStartIndex, 0, null);
+        context.splice(singleClassesStartIndex, 0, null);
+        singleClassesStartIndex++;
+        multiStylesStartIndex++;
+        multiClassesStartIndex += 2; // both single + multi slots were inserted
+    }
+    // this is where we make space in the context for the new class bindings
+    for (let i = 0; i < filteredClassBindingNames.length * 4 /* Size */; i++) {
+        context.splice(multiStylesStartIndex, 0, null);
         context.push(null);
+        multiStylesStartIndex++;
+        multiClassesStartIndex++;
     }
     /** @type {?} */
-    const singleStart = 8 /* SingleStylesStartPosition */;
+    const initialClasses = context[3 /* InitialClassValuesPosition */];
     /** @type {?} */
-    const multiStart = totalProps * 4 /* Size */ + 8 /* SingleStylesStartPosition */;
-    // fill single and multi-level styles
-    for (let i = 0; i < totalProps; i++) {
+    const initialStyles = context[2 /* InitialStyleValuesPosition */];
+    // the code below will insert each new entry into the context and assign the appropriate
+    // flags and index values to them. It's important this runs at the end of this function
+    // because the context, property offset and index values have all been computed just before.
+    for (let i = 0; i < totalNewEntries; i++) {
         /** @type {?} */
-        const isClassBased = i >= classNamesIndexStart;
+        const entryIsClassBased = i >= filteredStyleBindingNames.length;
         /** @type {?} */
-        const prop = isClassBased ? classNames[i - classNamesIndexStart] : styleProps[i];
+        const adjustedIndex = entryIsClassBased ? (i - filteredStyleBindingNames.length) : i;
         /** @type {?} */
-        const indexForInitial = isClassBased ? classesLookup[prop] : stylesLookup[prop];
+        const propName = entryIsClassBased ? filteredClassBindingNames[adjustedIndex] :
+            filteredStyleBindingNames[adjustedIndex];
         /** @type {?} */
-        const initialValue = initialStylingValues[indexForInitial];
+        let multiIndex;
         /** @type {?} */
-        const indexForMulti = i * 4 /* Size */ + multiStart;
+        let singleIndex;
+        if (entryIsClassBased) {
+            multiIndex = multiClassesStartIndex +
+                ((totalCurrentClassBindings + adjustedIndex) * 4 /* Size */);
+            singleIndex = singleClassesStartIndex +
+                ((totalCurrentClassBindings + adjustedIndex) * 4 /* Size */);
+        }
+        else {
+            multiIndex =
+                multiStylesStartIndex + ((totalCurrentStyleBindings + adjustedIndex) * 4 /* Size */);
+            singleIndex = singleStylesStartIndex +
+                ((totalCurrentStyleBindings + adjustedIndex) * 4 /* Size */);
+        }
+        // if a property is not found in the initial style values list then it
+        // is ALWAYS added incase a follow-up directive introduces the same initial
+        // style/class value later on.
         /** @type {?} */
-        const indexForSingle = i * 4 /* Size */ + singleStart;
+        let initialValuesToLookup = entryIsClassBased ? initialClasses : initialStyles;
         /** @type {?} */
-        const initialFlag = prepareInitialFlag(prop, isClassBased, styleSanitizer || null);
-        setFlag(context, indexForSingle, pointers(initialFlag, indexForInitial, indexForMulti));
-        setProp(context, indexForSingle, prop);
-        setValue(context, indexForSingle, null);
-        setPlayerBuilderIndex(context, indexForSingle, 0);
+        let indexForInitial = getInitialStylingValuesIndexOf(initialValuesToLookup, propName);
+        if (indexForInitial === -1) {
+            indexForInitial = initialValuesToLookup.length + 1 /* ValueOffset */;
+            initialValuesToLookup.push(propName, entryIsClassBased ? false : null);
+        }
+        else {
+            indexForInitial += 1 /* ValueOffset */;
+        }
         /** @type {?} */
-        const flagForMulti = initialFlag | (initialValue !== null ? 1 /* Dirty */ : 0 /* None */);
-        setFlag(context, indexForMulti, pointers(flagForMulti, indexForInitial, indexForSingle));
-        setProp(context, indexForMulti, prop);
-        setValue(context, indexForMulti, null);
-        setPlayerBuilderIndex(context, indexForMulti, 0);
+        const initialFlag = prepareInitialFlag(context, propName, entryIsClassBased, styleSanitizer || null);
+        setFlag(context, singleIndex, pointers(initialFlag, indexForInitial, multiIndex));
+        setProp(context, singleIndex, propName);
+        setValue(context, singleIndex, null);
+        setPlayerBuilderIndex(context, singleIndex, 0, directiveIndex);
+        setFlag(context, multiIndex, pointers(initialFlag, indexForInitial, singleIndex));
+        setProp(context, multiIndex, propName);
+        setValue(context, multiIndex, null);
+        setPlayerBuilderIndex(context, multiIndex, 0, directiveIndex);
     }
-    /** @type {?} */
-    const masterFlag = pointers(0, 0, multiStart) |
+    // the total classes/style values are updated so the next time the context is patched
+    // additional style/class bindings from another directive then it knows exactly where
+    // to insert them in the context
+    singlePropOffsetValues[1 /* ClassesCountPosition */] =
+        totalCurrentClassBindings + filteredClassBindingNames.length;
+    singlePropOffsetValues[0 /* StylesCountPosition */] =
+        totalCurrentStyleBindings + filteredStyleBindingNames.length;
+    // there is no initial value flag for the master index since it doesn't
+    // reference an initial style value
+    /** @type {?} */
+    const masterFlag = pointers(0, 0, multiStylesStartIndex) |
         (onlyProcessSingleClasses ? 16 /* OnlyProcessSingleClasses */ : 0);
-    setFlag(context, 3 /* MasterFlagPosition */, masterFlag);
-    setContextDirty(context, initialStylingValues.length > 1);
-    if (initialStaticClasses) {
-        context[6 /* PreviousOrCachedMultiClassValue */] = initialStaticClasses.join(' ');
+    setFlag(context, 0 /* MasterFlagPosition */, masterFlag);
+}
+/**
+ * Searches through the existing registry of directives
+ * @param {?} context
+ * @param {?} directiveRef
+ * @param {?=} styleSanitizer
+ * @return {?}
+ */
+function findOrPatchDirectiveIntoRegistry(context, directiveRef, styleSanitizer) {
+    /** @type {?} */
+    const directiveRefs = context[1 /* DirectiveRegistryPosition */];
+    /** @type {?} */
+    const nextOffsetInsertionIndex = context[4 /* SinglePropOffsetPositions */].length;
+    /** @type {?} */
+    let directiveIndex;
+    /** @type {?} */
+    const detectedIndex = getDirectiveRegistryValuesIndexOf(directiveRefs, directiveRef);
+    if (detectedIndex === -1) {
+        directiveIndex = directiveRefs.length / 4 /* Size */;
+        directiveRefs.push(directiveRef, nextOffsetInsertionIndex, false, styleSanitizer || null);
     }
-    return context;
+    else {
+        /** @type {?} */
+        const singlePropStartPosition = detectedIndex + 1 /* SinglePropValuesIndexOffset */;
+        if ((/** @type {?} */ (directiveRefs[singlePropStartPosition])) >= 0) {
+            // the directive has already been patched into the context
+            return -1;
+        }
+        directiveIndex = detectedIndex / 4 /* Size */;
+        // because the directive already existed this means that it was set during elementHostAttrs or
+        // elementStart which means that the binding values were not here. Therefore, the values below
+        // need to be applied so that single class and style properties can be assigned later.
+        /** @type {?} */
+        const singlePropPositionIndex = detectedIndex + 1 /* SinglePropValuesIndexOffset */;
+        directiveRefs[singlePropPositionIndex] = nextOffsetInsertionIndex;
+        // the sanitizer is also apart of the binding process and will be used when bindings are
+        // applied.
+        /** @type {?} */
+        const styleSanitizerIndex = detectedIndex + 3 /* StyleSanitizerOffset */;
+        directiveRefs[styleSanitizerIndex] = styleSanitizer || null;
+    }
+    return directiveIndex;
+}
+/**
+ * @param {?} context
+ * @param {?} bindingName
+ * @param {?} start
+ * @param {?} end
+ * @return {?}
+ */
+function getMatchingBindingIndex(context, bindingName, start, end) {
+    for (let j = start; j < end; j += 4 /* Size */) {
+        if (getProp(context, j) === bindingName)
+            return j;
+    }
+    return -1;
 }
 /**
  * Sets and resolves all `multi` styling on an `StylingContext` so that they can be
- * applied to the element once `renderStyleAndClassBindings` is called.
+ * applied to the element once `renderStyling` is called.
  *
  * All missing styles/class (any values that are not provided in the new `styles`
  * or `classes` params) will resolve to `null` within their respective positions
@@ -171,36 +482,41 @@ export function createStylingContextTemplate(initialClassDeclarations, initialSt
  *    newly provided style values.
  * @param {?} classesInput The key/value map of CSS class names that will be used for the update.
  * @param {?=} stylesInput The key/value map of CSS styles that will be used for the update.
+ * @param {?=} directiveRef
  * @return {?}
  */
-export function updateStylingMap(context, classesInput, stylesInput) {
+export function updateStylingMap(context, classesInput, stylesInput, directiveRef) {
     stylesInput = stylesInput || null;
     /** @type {?} */
-    const element = /** @type {?} */ (((context[5 /* ElementPosition */])));
+    const directiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);
+    /** @type {?} */
+    const element = (/** @type {?} */ ((/** @type {?} */ (context[5 /* ElementPosition */]))));
     /** @type {?} */
     const classesPlayerBuilder = classesInput instanceof BoundPlayerFactory ?
-        new ClassAndStylePlayerBuilder(/** @type {?} */ (classesInput), element, 1 /* Class */) :
+        new ClassAndStylePlayerBuilder((/** @type {?} */ (classesInput)), element, 1 /* Class */) :
         null;
     /** @type {?} */
     const stylesPlayerBuilder = stylesInput instanceof BoundPlayerFactory ?
-        new ClassAndStylePlayerBuilder(/** @type {?} */ (stylesInput), element, 2 /* Style */) :
+        new ClassAndStylePlayerBuilder((/** @type {?} */ (stylesInput)), element, 2 /* Style */) :
         null;
     /** @type {?} */
-    const classesValue = classesPlayerBuilder ? /** @type {?} */ (((/** @type {?} */ (classesInput)))).value :
+    const classesValue = classesPlayerBuilder ?
+        (/** @type {?} */ (((/** @type {?} */ (classesInput))))).value :
         classesInput;
     /** @type {?} */
-    const stylesValue = stylesPlayerBuilder ? stylesInput["value"] : stylesInput;
+    const stylesValue = stylesPlayerBuilder ? (/** @type {?} */ (stylesInput)).value : stylesInput;
+    // early exit (this is what's done to avoid using ctx.bind() to cache the value)
     /** @type {?} */
     const ignoreAllClassUpdates = limitToSingleClasses(context) || classesValue === NO_CHANGE ||
-        classesValue === context[6 /* PreviousOrCachedMultiClassValue */];
+        classesValue === context[6 /* CachedClassValueOrInitialClassString */];
     /** @type {?} */
-    const ignoreAllStyleUpdates = stylesValue === NO_CHANGE || stylesValue === context[7 /* PreviousMultiStyleValue */];
+    const ignoreAllStyleUpdates = stylesValue === NO_CHANGE || stylesValue === context[7 /* CachedStyleValue */];
     if (ignoreAllClassUpdates && ignoreAllStyleUpdates)
         return;
-    context[6 /* PreviousOrCachedMultiClassValue */] = classesValue;
-    context[7 /* PreviousMultiStyleValue */] = stylesValue;
+    context[6 /* CachedClassValueOrInitialClassString */] = classesValue;
+    context[7 /* CachedStyleValue */] = stylesValue;
     /** @type {?} */
-    let classNames = EMPTY_ARR;
+    let classNames = EMPTY_ARRAY;
     /** @type {?} */
     let applyAllClasses = false;
     /** @type {?} */
@@ -227,19 +543,19 @@ export function updateStylingMap(context, classesInput, stylesInput) {
             applyAllClasses = true;
         }
         else {
-            classNames = classesValue ? Object.keys(classesValue) : EMPTY_ARR;
+            classNames = classesValue ? Object.keys(classesValue) : EMPTY_ARRAY;
         }
     }
     /** @type {?} */
-    const classes = /** @type {?} */ ((classesValue || EMPTY_OBJ));
+    const classes = (/** @type {?} */ ((classesValue || EMPTY_OBJ)));
     /** @type {?} */
-    const styleProps = stylesValue ? Object.keys(stylesValue) : EMPTY_ARR;
+    const styleProps = stylesValue ? Object.keys(stylesValue) : EMPTY_ARRAY;
     /** @type {?} */
     const styles = stylesValue || EMPTY_OBJ;
     /** @type {?} */
     const classesStartIndex = styleProps.length;
     /** @type {?} */
-    const multiStartIndex = getMultiStartIndex(context);
+    let multiStartIndex = getMultiStartIndex(context);
     /** @type {?} */
     let dirty = false;
     /** @type {?} */
@@ -274,15 +590,19 @@ export function updateStylingMap(context, classesInput, stylesInput) {
                 const value = getValue(context, ctxIndex);
                 /** @type {?} */
                 const flag = getPointers(context, ctxIndex);
-                setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex);
+                setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex, directiveIndex);
                 if (hasValueChanged(flag, value, newValue)) {
                     setValue(context, ctxIndex, newValue);
                     playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;
                     /** @type {?} */
                     const initialValue = getInitialValue(context, flag);
-                    // there is no point in setting this to dirty if the previously
-                    // rendered value was being referenced by the initial style (or null)
-                    if (hasValueChanged(flag, initialValue, newValue)) {
+                    // SKIP IF INITIAL CHECK
+                    // If the former `value` is `null` then it means that an initial value
+                    // could be being rendered on screen. If that is the case then there is
+                    // no point in updating the value incase it matches. In other words if the
+                    // new value is the exact same as the previously rendered value (which
+                    // happens to be the initial value) then do nothing.
+                    if (value != null || hasValueChanged(flag, initialValue, newValue)) {
                         setDirty(context, ctxIndex, true);
                         dirty = true;
                     }
@@ -292,6 +612,7 @@ export function updateStylingMap(context, classesInput, stylesInput) {
                 /** @type {?} */
                 const indexOfEntry = findEntryPositionByProp(context, newProp, ctxIndex);
                 if (indexOfEntry > 0) {
+                    // it was found at a later point ... just swap the values
                     /** @type {?} */
                     const valueToCompare = getValue(context, indexOfEntry);
                     /** @type {?} */
@@ -301,7 +622,8 @@ export function updateStylingMap(context, classesInput, stylesInput) {
                         /** @type {?} */
                         const initialValue = getInitialValue(context, flagToCompare);
                         setValue(context, ctxIndex, newValue);
-                        if (hasValueChanged(flagToCompare, initialValue, newValue)) {
+                        // same if statement logic as above (look for SKIP IF INITIAL CHECK).
+                        if (valueToCompare != null || hasValueChanged(flagToCompare, initialValue, newValue)) {
                             setDirty(context, ctxIndex, true);
                             playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;
                             dirty = true;
@@ -309,10 +631,11 @@ export function updateStylingMap(context, classesInput, stylesInput) {
                     }
                 }
                 else {
+                    // we only care to do this if the insertion is in the middle
                     /** @type {?} */
-                    const newFlag = prepareInitialFlag(newProp, isClassBased, getStyleSanitizer(context));
+                    const newFlag = prepareInitialFlag(context, newProp, isClassBased, getStyleSanitizer(context, directiveIndex));
                     playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;
-                    insertNewMultiProperty(context, ctxIndex, isClassBased, newProp, newFlag, newValue, playerBuilderIndex);
+                    insertNewMultiProperty(context, ctxIndex, isClassBased, newProp, newFlag, newValue, directiveIndex, playerBuilderIndex);
                     dirty = true;
                 }
             }
@@ -338,16 +661,22 @@ export function updateStylingMap(context, classesInput, stylesInput) {
             if (doRemoveValue) {
                 setDirty(context, ctxIndex, true);
                 setValue(context, ctxIndex, null);
+                // we keep the player factory the same so that the `nulled` value can
+                // be instructed into the player because removing a style and/or a class
+                // is a valid animation player instruction.
                 /** @type {?} */
                 const playerBuilderIndex = isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
-                setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex);
+                setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex, directiveIndex);
                 dirty = true;
             }
         }
         ctxIndex += 4 /* Size */;
     }
+    // this means that there are left-over properties in the context that
+    // were not detected in the context during the loop above. In that
+    // case we want to add the new entries into the list
     /** @type {?} */
-    const sanitizer = getStyleSanitizer(context);
+    const sanitizer = getStyleSanitizer(context, directiveIndex);
     while (propIndex < propLimit) {
         /** @type {?} */
         const isClassBased = propIndex >= classesStartIndex;
@@ -361,24 +690,42 @@ export function updateStylingMap(context, classesInput, stylesInput) {
             /** @type {?} */
             const value = isClassBased ? (applyAllClasses ? true : classes[prop]) : styles[prop];
             /** @type {?} */
-            const flag = prepareInitialFlag(prop, isClassBased, sanitizer) | 1 /* Dirty */;
+            const flag = prepareInitialFlag(context, prop, isClassBased, sanitizer) | 1 /* Dirty */;
             /** @type {?} */
             const playerBuilderIndex = isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
-            context.push(flag, prop, value, playerBuilderIndex);
+            /** @type {?} */
+            const ctxIndex = context.length;
+            context.push(flag, prop, value, 0);
+            setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex, directiveIndex);
             dirty = true;
         }
         propIndex++;
     }
     if (dirty) {
         setContextDirty(context, true);
+        setDirectiveDirty(context, directiveIndex, true);
     }
     if (playerBuildersAreDirty) {
         setContextPlayersDirty(context, true);
     }
 }
 /**
- * Sets and resolves a single styling property/value on the provided `StylingContext` so
- * that they can be applied to the element once `renderStyleAndClassBindings` is called.
+ * This method will toggle the referenced CSS class (by the provided index)
+ * within the given context.
+ *
+ * @param {?} context The styling context that will be updated with the
+ *    newly provided class value.
+ * @param {?} offset The index of the CSS class which is being updated.
+ * @param {?} addOrRemove Whether or not to add or remove the CSS class
+ * @param {?=} directiveRef
+ * @return {?}
+ */
+export function updateClassProp(context, offset, addOrRemove, directiveRef) {
+    _updateSingleStylingValue(context, offset, addOrRemove, true, directiveRef);
+}
+/**
+ * Sets and resolves a single style value on the provided `StylingContext` so
+ * that they can be applied to the element once `renderStyling` is called.
  *
  * Note that prop-level styling values are considered higher priority than any styling that
  * has been applied using `updateStylingMap`, therefore, when styling values are rendered
@@ -387,31 +734,50 @@ export function updateStylingMap(context, classesInput, stylesInput) {
  *
  * @param {?} context The styling context that will be updated with the
  *    newly provided style value.
- * @param {?} index The index of the property which is being updated.
+ * @param {?} offset The index of the property which is being updated.
  * @param {?} input
+ * @param {?=} directiveRef an optional reference to the directive responsible
+ *    for this binding change. If present then style binding will only
+ *    actualize if the directive has ownership over this binding
+ *    (see styling.ts#directives for more information about the algorithm).
  * @return {?}
  */
-export function updateStyleProp(context, index, input) {
+export function updateStyleProp(context, offset, input, directiveRef) {
+    _updateSingleStylingValue(context, offset, input, false, directiveRef);
+}
+/**
+ * @param {?} context
+ * @param {?} offset
+ * @param {?} input
+ * @param {?} isClassBased
+ * @param {?} directiveRef
+ * @return {?}
+ */
+function _updateSingleStylingValue(context, offset, input, isClassBased, directiveRef) {
     /** @type {?} */
-    const singleIndex = 8 /* SingleStylesStartPosition */ + index * 4 /* Size */;
+    const directiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);
+    /** @type {?} */
+    const singleIndex = getSinglePropIndexValue(context, directiveIndex, offset, isClassBased);
     /** @type {?} */
     const currValue = getValue(context, singleIndex);
     /** @type {?} */
     const currFlag = getPointers(context, singleIndex);
     /** @type {?} */
+    const currDirective = getDirectiveIndexFromEntry(context, singleIndex);
+    /** @type {?} */
     const value = (input instanceof BoundPlayerFactory) ? input.value : input;
-    // didn't change ... nothing to make a note of
-    if (hasValueChanged(currFlag, currValue, value)) {
+    if (hasValueChanged(currFlag, currValue, value) &&
+        allowValueChange(currValue, value, currDirective, directiveIndex)) {
         /** @type {?} */
         const isClassBased = (currFlag & 2 /* Class */) === 2 /* Class */;
         /** @type {?} */
-        const element = /** @type {?} */ (((context[5 /* ElementPosition */])));
+        const element = (/** @type {?} */ ((/** @type {?} */ (context[5 /* ElementPosition */]))));
         /** @type {?} */
         const playerBuilder = input instanceof BoundPlayerFactory ?
-            new ClassAndStylePlayerBuilder(/** @type {?} */ (input), element, isClassBased ? 1 /* Class */ : 2 /* Style */) :
+            new ClassAndStylePlayerBuilder((/** @type {?} */ (input)), element, isClassBased ? 1 /* Class */ : 2 /* Style */) :
             null;
         /** @type {?} */
-        const value = /** @type {?} */ ((playerBuilder ? (/** @type {?} */ (input)).value : input));
+        const value = (/** @type {?} */ ((playerBuilder ? ((/** @type {?} */ (input))).value : input)));
         /** @type {?} */
         const currPlayerIndex = getPlayerBuilderIndex(context, singleIndex);
         /** @type {?} */
@@ -422,13 +788,23 @@ export function updateStyleProp(context, index, input) {
             /** @type {?} */
             const newIndex = setPlayerBuilder(context, playerBuilder, currPlayerIndex);
             playerBuilderIndex = playerBuilder ? newIndex : 0;
-            setPlayerBuilderIndex(context, singleIndex, playerBuilderIndex);
             playerBuildersAreDirty = true;
         }
+        if (playerBuildersAreDirty || currDirective !== directiveIndex) {
+            setPlayerBuilderIndex(context, singleIndex, playerBuilderIndex, directiveIndex);
+        }
+        if (currDirective !== directiveIndex) {
+            /** @type {?} */
+            const prop = getProp(context, singleIndex);
+            /** @type {?} */
+            const sanitizer = getStyleSanitizer(context, directiveIndex);
+            setSanitizeFlag(context, singleIndex, (sanitizer && sanitizer(prop)) ? true : false);
+        }
         // the value will always get updated (even if the dirty flag is skipped)
         setValue(context, singleIndex, value);
         /** @type {?} */
         const indexForMulti = getMultiOrSingleIndex(currFlag);
+        // if the value is the same in the multi-area then there's no point in re-assembling
         /** @type {?} */
         const valueForMulti = getValue(context, indexForMulti);
         if (!valueForMulti || hasValueChanged(currFlag, valueForMulti, value)) {
@@ -443,6 +819,7 @@ export function updateStyleProp(context, index, input) {
             }
             setDirty(context, indexForMulti, multiDirty);
             setDirty(context, singleIndex, singleDirty);
+            setDirectiveDirty(context, directiveIndex, true);
             setContextDirty(context, true);
         }
         if (playerBuildersAreDirty) {
@@ -450,21 +827,6 @@ export function updateStyleProp(context, index, input) {
         }
     }
 }
-/**
- * This method will toggle the referenced CSS class (by the provided index)
- * within the given context.
- *
- * @param {?} context The styling context that will be updated with the
- *    newly provided class value.
- * @param {?} index The index of the CSS class which is being updated.
- * @param {?} addOrRemove Whether or not to add or remove the CSS class
- * @return {?}
- */
-export function updateClassProp(context, index, addOrRemove) {
-    /** @type {?} */
-    const adjustedIndex = index + context[4 /* ClassOffsetPosition */];
-    updateStyleProp(context, adjustedIndex, addOrRemove);
-}
 /**
  * Renders all queued styling using a renderer onto the given element.
  *
@@ -483,31 +845,44 @@ export function updateClassProp(context, index, addOrRemove) {
  *    to this key/value map instead of being renderered via the renderer.
  * @param {?=} stylesStore if provided, the updated style values will be applied
  *    to this key/value map instead of being renderered via the renderer.
+ * @param {?=} directiveRef an optional directive that will be used to target which
+ *    styling values are rendered. If left empty, only the bindings that are
+ *    registered on the template will be rendered.
  * @return {?} number the total amount of players that got queued for animation (if any)
  */
-export function renderStyleAndClassBindings(context, renderer, rootOrView, isFirstRender, classesStore, stylesStore) {
+export function renderStyling(context, renderer, rootOrView, isFirstRender, classesStore, stylesStore, directiveRef) {
     /** @type {?} */
     let totalPlayersQueued = 0;
-    if (isContextDirty(context)) {
+    /** @type {?} */
+    const targetDirectiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);
+    if (isContextDirty(context) && isDirectiveDirty(context, targetDirectiveIndex)) {
         /** @type {?} */
-        const flushPlayerBuilders = context[3 /* MasterFlagPosition */] & 8 /* PlayerBuildersDirty */;
+        const flushPlayerBuilders = context[0 /* MasterFlagPosition */] & 8 /* PlayerBuildersDirty */;
         /** @type {?} */
-        const native = /** @type {?} */ ((context[5 /* ElementPosition */]));
+        const native = (/** @type {?} */ (context[5 /* ElementPosition */]));
         /** @type {?} */
         const multiStartIndex = getMultiStartIndex(context);
         /** @type {?} */
-        const styleSanitizer = getStyleSanitizer(context);
-        /** @type {?} */
         const onlySingleClasses = limitToSingleClasses(context);
-        for (let i = 8 /* SingleStylesStartPosition */; i < context.length; i += 4 /* Size */) {
+        /** @type {?} */
+        let stillDirty = false;
+        for (let i = 9 /* SingleStylesStartPosition */; i < context.length; i += 4 /* Size */) {
             // there is no point in rendering styles that have not changed on screen
             if (isDirty(context, i)) {
+                /** @type {?} */
+                const flag = getPointers(context, i);
+                /** @type {?} */
+                const directiveIndex = getDirectiveIndexFromEntry(context, i);
+                if (targetDirectiveIndex !== directiveIndex) {
+                    stillDirty = true;
+                    continue;
+                }
                 /** @type {?} */
                 const prop = getProp(context, i);
                 /** @type {?} */
                 const value = getValue(context, i);
                 /** @type {?} */
-                const flag = getPointers(context, i);
+                const styleSanitizer = (flag & 4 /* Sanitize */) ? getStyleSanitizer(context, directiveIndex) : null;
                 /** @type {?} */
                 const playerBuilder = getPlayerBuilder(context, i);
                 /** @type {?} */
@@ -522,6 +897,7 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
                 // this check implies that a single value was removed and we
                 // should now defer to a multi value and use that (if set).
                 if (isInSingleRegion && !valueExists(valueToApply, isClassBased)) {
+                    // single values ALWAYS have a reference to a multi index
                     /** @type {?} */
                     const multiIndex = getMultiOrSingleIndex(flag);
                     valueToApply = getValue(context, multiIndex);
@@ -532,9 +908,15 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
                 // note that this should always be a falsy check since `false` is used
                 // for both class and style comparisons (styles can't be false and false
                 // classes are turned off and should therefore defer to their initial values)
-                if (!valueExists(valueToApply, isClassBased) && readInitialValue) {
+                // Note that we ignore class-based deferals because otherwise a class can never
+                // be removed in the case that it exists as true in the initial classes list...
+                if (!isClassBased && !valueExists(valueToApply, isClassBased) && readInitialValue) {
                     valueToApply = getInitialValue(context, flag);
                 }
+                // if the first render is true then we do not want to start applying falsy
+                // values to the DOM element's styling. Otherwise then we know there has
+                // been a change and even if it's falsy then it's removing something that
+                // was truthy before.
                 /** @type {?} */
                 const doApplyValue = isFirstRender ? valueToApply : true;
                 if (doApplyValue) {
@@ -542,9 +924,7 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
                         setClass(native, prop, valueToApply ? true : false, renderer, classesStore, playerBuilder);
                     }
                     else {
-                        /** @type {?} */
-                        const sanitizer = (flag & 4 /* Sanitize */) ? styleSanitizer : null;
-                        setStyle(native, prop, /** @type {?} */ (valueToApply), renderer, sanitizer, stylesStore, playerBuilder);
+                        setStyle(native, prop, (/** @type {?} */ (valueToApply)), renderer, styleSanitizer, stylesStore, playerBuilder);
                     }
                 }
                 setDirty(context, i, false);
@@ -552,25 +932,25 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
         }
         if (flushPlayerBuilders) {
             /** @type {?} */
-            const rootContext = Array.isArray(rootOrView) ? getRootContext(rootOrView) : /** @type {?} */ (rootOrView);
+            const rootContext = Array.isArray(rootOrView) ? getRootContext(rootOrView) : (/** @type {?} */ (rootOrView));
             /** @type {?} */
-            const playerContext = /** @type {?} */ ((getPlayerContext(context)));
+            const playerContext = (/** @type {?} */ (getPlayerContext(context)));
             /** @type {?} */
             const playersStartIndex = playerContext[0 /* NonBuilderPlayersStart */];
             for (let i = 1 /* PlayerBuildersStartPosition */; i < playersStartIndex; i += 2 /* PlayerAndPlayerBuildersTupleSize */) {
                 /** @type {?} */
-                const builder = /** @type {?} */ (playerContext[i]);
+                const builder = (/** @type {?} */ (playerContext[i]));
                 /** @type {?} */
                 const playerInsertionIndex = i + 1 /* PlayerOffsetPosition */;
                 /** @type {?} */
-                const oldPlayer = /** @type {?} */ (playerContext[playerInsertionIndex]);
+                const oldPlayer = (/** @type {?} */ (playerContext[playerInsertionIndex]));
                 if (builder) {
                     /** @type {?} */
                     const player = builder.buildPlayer(oldPlayer, isFirstRender);
                     if (player !== undefined) {
                         if (player != null) {
                             /** @type {?} */
-                            const wasQueued = addPlayerInternal(playerContext, rootContext, /** @type {?} */ (native), player, playerInsertionIndex);
+                            const wasQueued = addPlayerInternal(playerContext, rootContext, (/** @type {?} */ (native)), player, playerInsertionIndex);
                             wasQueued && totalPlayersQueued++;
                         }
                         if (oldPlayer) {
@@ -586,7 +966,8 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
             }
             setContextPlayersDirty(context, false);
         }
-        setContextDirty(context, false);
+        setDirectiveDirty(context, targetDirectiveIndex, false);
+        setContextDirty(context, stillDirty);
     }
     return totalPlayersQueued;
 }
@@ -605,7 +986,7 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
  * @param {?=} playerBuilder
  * @return {?}
  */
-function setStyle(native, prop, value, renderer, sanitizer, store, playerBuilder) {
+export function setStyle(native, prop, value, renderer, sanitizer, store, playerBuilder) {
     value = sanitizer && value ? sanitizer(prop, value) : value;
     if (store || playerBuilder) {
         if (store) {
@@ -616,6 +997,8 @@ function setStyle(native, prop, value, renderer, sanitizer, store, playerBuilder
         }
     }
     else if (value) {
+        value = value.toString(); // opacity, z-index and flexbox all have number values which may not
+        // assign as numbers
         ngDevMode && ngDevMode.rendererSetStyle++;
         isProceduralRenderer(renderer) ?
             renderer.setStyle(native, prop, value, RendererStyleFlags3.DashCase) :
@@ -662,6 +1045,20 @@ function setClass(native, className, add, renderer, store, playerBuilder) {
             native['classList'].remove(className);
     }
 }
+/**
+ * @param {?} context
+ * @param {?} index
+ * @param {?} sanitizeYes
+ * @return {?}
+ */
+function setSanitizeFlag(context, index, sanitizeYes) {
+    if (sanitizeYes) {
+        ((/** @type {?} */ (context[index]))) |= 4 /* Sanitize */;
+    }
+    else {
+        ((/** @type {?} */ (context[index]))) &= ~4 /* Sanitize */;
+    }
+}
 /**
  * @param {?} context
  * @param {?} index
@@ -670,12 +1067,12 @@ function setClass(native, className, add, renderer, store, playerBuilder) {
  */
 function setDirty(context, index, isDirtyYes) {
     /** @type {?} */
-    const adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+    const adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
     if (isDirtyYes) {
-        (/** @type {?} */ (context[adjustedIndex])) |= 1 /* Dirty */;
+        ((/** @type {?} */ (context[adjustedIndex]))) |= 1 /* Dirty */;
     }
     else {
-        (/** @type {?} */ (context[adjustedIndex])) &= ~1 /* Dirty */;
+        ((/** @type {?} */ (context[adjustedIndex]))) &= ~1 /* Dirty */;
     }
 }
 /**
@@ -685,18 +1082,18 @@ function setDirty(context, index, isDirtyYes) {
  */
 function isDirty(context, index) {
     /** @type {?} */
-    const adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
-    return ((/** @type {?} */ (context[adjustedIndex])) & 1 /* Dirty */) == 1 /* Dirty */;
+    const adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+    return (((/** @type {?} */ (context[adjustedIndex]))) & 1 /* Dirty */) == 1 /* Dirty */;
 }
 /**
  * @param {?} context
  * @param {?} index
  * @return {?}
  */
-function isClassBased(context, index) {
+export function isClassBasedValue(context, index) {
     /** @type {?} */
-    const adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
-    return ((/** @type {?} */ (context[adjustedIndex])) & 2 /* Class */) == 2 /* Class */;
+    const adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+    return (((/** @type {?} */ (context[adjustedIndex]))) & 2 /* Class */) == 2 /* Class */;
 }
 /**
  * @param {?} context
@@ -705,8 +1102,8 @@ function isClassBased(context, index) {
  */
 function isSanitizable(context, index) {
     /** @type {?} */
-    const adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
-    return ((/** @type {?} */ (context[adjustedIndex])) & 4 /* Sanitize */) == 4 /* Sanitize */;
+    const adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+    return (((/** @type {?} */ (context[adjustedIndex]))) & 4 /* Sanitize */) == 4 /* Sanitize */;
 }
 /**
  * @param {?} configFlag
@@ -715,8 +1112,8 @@ function isSanitizable(context, index) {
  * @return {?}
  */
 function pointers(configFlag, staticIndex, dynamicIndex) {
-    return (configFlag & 31 /* BitMask */) | (staticIndex << 5 /* BitCountSize */) |
-        (dynamicIndex << (14 /* BitCountSize */ + 5 /* BitCountSize */));
+    return (configFlag & 63 /* BitMask */) | (staticIndex << 6 /* BitCountSize */) |
+        (dynamicIndex << (14 /* BitCountSize */ + 6 /* BitCountSize */));
 }
 /**
  * @param {?} context
@@ -726,14 +1123,19 @@ function pointers(configFlag, staticIndex, dynamicIndex) {
 function getInitialValue(context, flag) {
     /** @type {?} */
     const index = getInitialIndex(flag);
-    return /** @type {?} */ (context[2 /* InitialStylesPosition */][index]);
+    /** @type {?} */
+    const entryIsClassBased = flag & 2 /* Class */;
+    /** @type {?} */
+    const initialValues = entryIsClassBased ? context[3 /* InitialClassValuesPosition */] :
+        context[2 /* InitialStyleValuesPosition */];
+    return initialValues[index];
 }
 /**
  * @param {?} flag
  * @return {?}
  */
 function getInitialIndex(flag) {
-    return (flag >> 5 /* BitCountSize */) & 16383 /* BitMask */;
+    return (flag >> 6 /* BitCountSize */) & 16383 /* BitMask */;
 }
 /**
  * @param {?} flag
@@ -741,22 +1143,15 @@ function getInitialIndex(flag) {
  */
 function getMultiOrSingleIndex(flag) {
     /** @type {?} */
-    const index = (flag >> (14 /* BitCountSize */ + 5 /* BitCountSize */)) & 16383 /* BitMask */;
-    return index >= 8 /* SingleStylesStartPosition */ ? index : -1;
+    const index = (flag >> (14 /* BitCountSize */ + 6 /* BitCountSize */)) & 16383 /* BitMask */;
+    return index >= 9 /* SingleStylesStartPosition */ ? index : -1;
 }
 /**
  * @param {?} context
  * @return {?}
  */
 function getMultiStartIndex(context) {
-    return /** @type {?} */ (getMultiOrSingleIndex(context[3 /* MasterFlagPosition */]));
-}
-/**
- * @param {?} context
- * @return {?}
- */
-function getStyleSanitizer(context) {
-    return context[1 /* StyleSanitizerPosition */];
+    return (/** @type {?} */ (getMultiOrSingleIndex(context[0 /* MasterFlagPosition */])));
 }
 /**
  * @param {?} context
@@ -784,7 +1179,7 @@ function setValue(context, index, value) {
  */
 function hasPlayerBuilderChanged(context, builder, index) {
     /** @type {?} */
-    const playerContext = /** @type {?} */ ((context[0 /* PlayerContext */]));
+    const playerContext = (/** @type {?} */ (context[8 /* PlayerContext */]));
     if (builder) {
         if (!playerContext || index === 0) {
             return true;
@@ -803,7 +1198,7 @@ function hasPlayerBuilderChanged(context, builder, index) {
  */
 function setPlayerBuilder(context, builder, insertionIndex) {
     /** @type {?} */
-    let playerContext = context[0 /* PlayerContext */] || allocPlayerContext(context);
+    let playerContext = context[8 /* PlayerContext */] || allocPlayerContext(context);
     if (insertionIndex > 0) {
         playerContext[insertionIndex] = builder;
     }
@@ -815,14 +1210,25 @@ function setPlayerBuilder(context, builder, insertionIndex) {
     }
     return insertionIndex;
 }
+/**
+ * @param {?} directiveIndex
+ * @param {?} playerIndex
+ * @return {?}
+ */
+export function directiveOwnerPointers(directiveIndex, playerIndex) {
+    return (playerIndex << 16 /* BitCountSize */) | directiveIndex;
+}
 /**
  * @param {?} context
  * @param {?} index
  * @param {?} playerBuilderIndex
+ * @param {?} directiveIndex
  * @return {?}
  */
-function setPlayerBuilderIndex(context, index, playerBuilderIndex) {
-    context[index + 3 /* PlayerBuilderIndexOffset */] = playerBuilderIndex;
+function setPlayerBuilderIndex(context, index, playerBuilderIndex, directiveIndex) {
+    /** @type {?} */
+    const value = directiveOwnerPointers(directiveIndex, playerBuilderIndex);
+    context[index + 3 /* PlayerBuilderIndexOffset */] = value;
 }
 /**
  * @param {?} context
@@ -830,7 +1236,12 @@ function setPlayerBuilderIndex(context, index, playerBuilderIndex) {
  * @return {?}
  */
 function getPlayerBuilderIndex(context, index) {
-    return (/** @type {?} */ (context[index + 3 /* PlayerBuilderIndexOffset */])) || 0;
+    /** @type {?} */
+    const flag = (/** @type {?} */ (context[index + 3 /* PlayerBuilderIndexOffset */]));
+    /** @type {?} */
+    const playerBuilderIndex = (flag >> 16 /* BitCountSize */) &
+        65535 /* BitMask */;
+    return playerBuilderIndex;
 }
 /**
  * @param {?} context
@@ -842,9 +1253,9 @@ function getPlayerBuilder(context, index) {
     const playerBuilderIndex = getPlayerBuilderIndex(context, index);
     if (playerBuilderIndex) {
         /** @type {?} */
-        const playerContext = context[0 /* PlayerContext */];
+        const playerContext = context[8 /* PlayerContext */];
         if (playerContext) {
-            return /** @type {?} */ (playerContext[playerBuilderIndex]);
+            return (/** @type {?} */ (playerContext[playerBuilderIndex]));
         }
     }
     return null;
@@ -857,7 +1268,7 @@ function getPlayerBuilder(context, index) {
  */
 function setFlag(context, index, flag) {
     /** @type {?} */
-    const adjustedIndex = index === 3 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
+    const adjustedIndex = index === 0 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
     context[adjustedIndex] = flag;
 }
 /**
@@ -867,38 +1278,38 @@ function setFlag(context, index, flag) {
  */
 function getPointers(context, index) {
     /** @type {?} */
-    const adjustedIndex = index === 3 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
-    return /** @type {?} */ (context[adjustedIndex]);
+    const adjustedIndex = index === 0 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
+    return (/** @type {?} */ (context[adjustedIndex]));
 }
 /**
  * @param {?} context
  * @param {?} index
  * @return {?}
  */
-function getValue(context, index) {
-    return /** @type {?} */ (context[index + 2 /* ValueOffset */]);
+export function getValue(context, index) {
+    return (/** @type {?} */ (context[index + 2 /* ValueOffset */]));
 }
 /**
  * @param {?} context
  * @param {?} index
  * @return {?}
  */
-function getProp(context, index) {
-    return /** @type {?} */ (context[index + 1 /* PropertyOffset */]);
+export function getProp(context, index) {
+    return (/** @type {?} */ (context[index + 1 /* PropertyOffset */]));
 }
 /**
  * @param {?} context
  * @return {?}
  */
 export function isContextDirty(context) {
-    return isDirty(context, 3 /* MasterFlagPosition */);
+    return isDirty(context, 0 /* MasterFlagPosition */);
 }
 /**
  * @param {?} context
  * @return {?}
  */
 export function limitToSingleClasses(context) {
-    return context[3 /* MasterFlagPosition */] & 16 /* OnlyProcessSingleClasses */;
+    return context[0 /* MasterFlagPosition */] & 16 /* OnlyProcessSingleClasses */;
 }
 /**
  * @param {?} context
@@ -906,7 +1317,7 @@ export function limitToSingleClasses(context) {
  * @return {?}
  */
 export function setContextDirty(context, isDirtyYes) {
-    setDirty(context, 3 /* MasterFlagPosition */, isDirtyYes);
+    setDirty(context, 0 /* MasterFlagPosition */, isDirtyYes);
 }
 /**
  * @param {?} context
@@ -915,10 +1326,10 @@ export function setContextDirty(context, isDirtyYes) {
  */
 export function setContextPlayersDirty(context, isDirtyYes) {
     if (isDirtyYes) {
-        (/** @type {?} */ (context[3 /* MasterFlagPosition */])) |= 8 /* PlayerBuildersDirty */;
+        ((/** @type {?} */ (context[0 /* MasterFlagPosition */]))) |= 8 /* PlayerBuildersDirty */;
     }
     else {
-        (/** @type {?} */ (context[3 /* MasterFlagPosition */])) &= ~8 /* PlayerBuildersDirty */;
+        ((/** @type {?} */ (context[0 /* MasterFlagPosition */]))) &= ~8 /* PlayerBuildersDirty */;
     }
 }
 /**
@@ -977,11 +1388,15 @@ function swapMultiContextEntries(context, indexA, indexB) {
     setValue(context, indexA, getValue(context, indexB));
     setProp(context, indexA, getProp(context, indexB));
     setFlag(context, indexA, getPointers(context, indexB));
-    setPlayerBuilderIndex(context, indexA, getPlayerBuilderIndex(context, indexB));
+    /** @type {?} */
+    const playerIndexA = getPlayerBuilderIndex(context, indexB);
+    /** @type {?} */
+    const directiveIndexA = 0;
+    setPlayerBuilderIndex(context, indexA, playerIndexA, directiveIndexA);
     setValue(context, indexB, tmpValue);
     setProp(context, indexB, tmpProp);
     setFlag(context, indexB, tmpFlag);
-    setPlayerBuilderIndex(context, indexB, tmpPlayerBuilderIndex);
+    setPlayerBuilderIndex(context, indexB, tmpPlayerBuilderIndex, directiveIndexA);
 }
 /**
  * @param {?} context
@@ -1001,7 +1416,7 @@ function updateSinglePointerValues(context, indexStartPosition) {
             const initialIndexForSingle = getInitialIndex(singleFlag);
             /** @type {?} */
             const flagValue = (isDirty(context, singleIndex) ? 1 /* Dirty */ : 0 /* None */) |
-                (isClassBased(context, singleIndex) ? 2 /* Class */ : 0 /* None */) |
+                (isClassBasedValue(context, singleIndex) ? 2 /* Class */ : 0 /* None */) |
                 (isSanitizable(context, singleIndex) ? 4 /* Sanitize */ : 0 /* None */);
             /** @type {?} */
             const updatedFlag = pointers(flagValue, initialIndexForSingle, i);
@@ -1016,14 +1431,16 @@ function updateSinglePointerValues(context, indexStartPosition) {
  * @param {?} name
  * @param {?} flag
  * @param {?} value
+ * @param {?} directiveIndex
  * @param {?} playerIndex
  * @return {?}
  */
-function insertNewMultiProperty(context, index, classBased, name, flag, value, playerIndex) {
+function insertNewMultiProperty(context, index, classBased, name, flag, value, directiveIndex, playerIndex) {
     /** @type {?} */
     const doShift = index < context.length;
     // prop does not exist in the list, add it in
-    context.splice(index, 0, flag | 1 /* Dirty */ | (classBased ? 2 /* Class */ : 0 /* None */), name, value, playerIndex);
+    context.splice(index, 0, flag | 1 /* Dirty */ | (classBased ? 2 /* Class */ : 0 /* None */), name, value, 0);
+    setPlayerBuilderIndex(context, index, playerIndex, directiveIndex);
     if (doShift) {
         // because the value was inserted midway into the array then we
         // need to update all the shifted multi values' single value
@@ -1043,19 +1460,28 @@ function valueExists(value, isClassBased) {
     return value !== null;
 }
 /**
- * @param {?} name
- * @param {?} isClassBased
+ * @param {?} context
+ * @param {?} prop
+ * @param {?} entryIsClassBased
  * @param {?=} sanitizer
  * @return {?}
  */
-function prepareInitialFlag(name, isClassBased, sanitizer) {
-    if (isClassBased) {
-        return 2 /* Class */;
+function prepareInitialFlag(context, prop, entryIsClassBased, sanitizer) {
+    /** @type {?} */
+    let flag = (sanitizer && sanitizer(prop)) ? 4 /* Sanitize */ : 0 /* None */;
+    /** @type {?} */
+    let initialIndex;
+    if (entryIsClassBased) {
+        flag |= 2 /* Class */;
+        initialIndex =
+            getInitialStylingValuesIndexOf(context[3 /* InitialClassValuesPosition */], prop);
     }
-    else if (sanitizer && sanitizer(name)) {
-        return 4 /* Sanitize */;
+    else {
+        initialIndex =
+            getInitialStylingValuesIndexOf(context[2 /* InitialStyleValuesPosition */], prop);
     }
-    return 0 /* None */;
+    initialIndex = initialIndex > 0 ? (initialIndex + 1 /* ValueOffset */) : 0;
+    return pointers(flag, initialIndex, 0);
 }
 /**
  * @param {?} flag
@@ -1075,7 +1501,7 @@ function hasValueChanged(flag, a, b) {
     // would fail since a new String() instance is created
     if (!isClassBased && hasValues && usesSanitizer) {
         // we know for sure we're dealing with strings at this point
-        return (/** @type {?} */ (a)).toString() !== (/** @type {?} */ (b)).toString();
+        return ((/** @type {?} */ (a))).toString() !== ((/** @type {?} */ (b))).toString();
     }
     // everything else is safe to check with a normal equality check
     return a !== b;
@@ -1094,7 +1520,7 @@ export class ClassAndStylePlayerBuilder {
         this._type = _type;
         this._values = {};
         this._dirty = false;
-        this._factory = /** @type {?} */ (factory);
+        this._factory = (/** @type {?} */ (factory));
     }
     /**
      * @param {?} prop
@@ -1118,7 +1544,7 @@ export class ClassAndStylePlayerBuilder {
         // `setValue` which means no new player will be provided.
         if (this._dirty) {
             /** @type {?} */
-            const player = this._factory.fn(this._element, this._type, /** @type {?} */ ((this._values)), isFirstRender, currentPlayer || null);
+            const player = this._factory.fn(this._element, this._type, (/** @type {?} */ (this._values)), isFirstRender, currentPlayer || null);
             this._values = {};
             this._dirty = false;
             return player;
@@ -1127,16 +1553,304 @@ export class ClassAndStylePlayerBuilder {
     }
 }
 if (false) {
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     ClassAndStylePlayerBuilder.prototype._values;
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     ClassAndStylePlayerBuilder.prototype._dirty;
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     ClassAndStylePlayerBuilder.prototype._factory;
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     ClassAndStylePlayerBuilder.prototype._element;
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     ClassAndStylePlayerBuilder.prototype._type;
 }
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class_and_style_bindings.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/styling/class_and_style_bindings.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {InitialStylingFlags} from '../interfaces/definition';\nimport {BindingStore, BindingType, Player, PlayerBuilder, PlayerFactory, PlayerIndex} from '../interfaces/player';\nimport {Renderer3, RendererStyleFlags3, isProceduralRenderer} from '../interfaces/renderer';\nimport {InitialStyles, StylingContext, StylingFlags, StylingIndex} from '../interfaces/styling';\nimport {LViewData, RootContext} from '../interfaces/view';\nimport {NO_CHANGE} from '../tokens';\nimport {getRootContext} from '../util';\n\nimport {BoundPlayerFactory} from './player_factory';\nimport {addPlayerInternal, allocPlayerContext, createEmptyStylingContext, getPlayerContext} from './util';\n\nconst EMPTY_ARR: any[] = [];\nconst EMPTY_OBJ: {[key: string]: any} = {};\n\n\n/**\n * Creates a styling context template where styling information is stored.\n * Any styles that are later referenced using `updateStyleProp` must be\n * passed in within this function. Initial values for those styles are to\n * be declared after all initial style properties are declared (this change in\n * mode between declarations and initial styles is made possible using a special\n * enum value found in `definition.ts`).\n *\n * @param initialStyleDeclarations a list of style declarations and initial style values\n *    that are used later within the styling context.\n *\n *    -> ['width', 'height', SPECIAL_ENUM_VAL, 'width', '100px']\n *       This implies that `width` and `height` will be later styled and that the `width`\n *       property has an initial value of `100px`.\n *\n * @param initialClassDeclarations a list of class declarations and initial class values\n *    that are used later within the styling context.\n *\n *    -> ['foo', 'bar', SPECIAL_ENUM_VAL, 'foo', true]\n *       This implies that `foo` and `bar` will be later styled and that the `foo`\n *       class will be applied to the element as an initial class since it's true\n */\nexport function createStylingContextTemplate(\n    initialClassDeclarations?: (string | boolean | InitialStylingFlags)[] | null,\n    initialStyleDeclarations?: (string | boolean | InitialStylingFlags)[] | null,\n    styleSanitizer?: StyleSanitizeFn | null, onlyProcessSingleClasses?: boolean): StylingContext {\n  const initialStylingValues: InitialStyles = [null];\n  const context: StylingContext =\n      createEmptyStylingContext(null, styleSanitizer, initialStylingValues);\n\n  // we use two maps since a class name might collide with a CSS style prop\n  const stylesLookup: {[key: string]: number} = {};\n  const classesLookup: {[key: string]: number} = {};\n\n  let totalStyleDeclarations = 0;\n  if (initialStyleDeclarations) {\n    let hasPassedDeclarations = false;\n    for (let i = 0; i < initialStyleDeclarations.length; i++) {\n      const v = initialStyleDeclarations[i] as string | InitialStylingFlags;\n\n      // this flag value marks where the declarations end the initial values begin\n      if (v === InitialStylingFlags.VALUES_MODE) {\n        hasPassedDeclarations = true;\n      } else {\n        const prop = v as string;\n        if (hasPassedDeclarations) {\n          const value = initialStyleDeclarations[++i] as string;\n          initialStylingValues.push(value);\n          stylesLookup[prop] = initialStylingValues.length - 1;\n        } else {\n          totalStyleDeclarations++;\n          stylesLookup[prop] = 0;\n        }\n      }\n    }\n  }\n\n  // make where the class offsets begin\n  context[StylingIndex.ClassOffsetPosition] = totalStyleDeclarations;\n\n  const initialStaticClasses: string[]|null = onlyProcessSingleClasses ? [] : null;\n  if (initialClassDeclarations) {\n    let hasPassedDeclarations = false;\n    for (let i = 0; i < initialClassDeclarations.length; i++) {\n      const v = initialClassDeclarations[i] as string | boolean | InitialStylingFlags;\n      // this flag value marks where the declarations end the initial values begin\n      if (v === InitialStylingFlags.VALUES_MODE) {\n        hasPassedDeclarations = true;\n      } else {\n        const className = v as string;\n        if (hasPassedDeclarations) {\n          const value = initialClassDeclarations[++i] as boolean;\n          initialStylingValues.push(value);\n          classesLookup[className] = initialStylingValues.length - 1;\n          initialStaticClasses && initialStaticClasses.push(className);\n        } else {\n          classesLookup[className] = 0;\n        }\n      }\n    }\n  }\n\n  const styleProps = Object.keys(stylesLookup);\n  const classNames = Object.keys(classesLookup);\n  const classNamesIndexStart = styleProps.length;\n  const totalProps = styleProps.length + classNames.length;\n\n  // *2 because we are filling for both single and multi style spaces\n  const maxLength = totalProps * StylingIndex.Size * 2 + StylingIndex.SingleStylesStartPosition;\n\n  // we need to fill the array from the start so that we can access\n  // both the multi and the single array positions in the same loop block\n  for (let i = StylingIndex.SingleStylesStartPosition; i < maxLength; i++) {\n    context.push(null);\n  }\n\n  const singleStart = StylingIndex.SingleStylesStartPosition;\n  const multiStart = totalProps * StylingIndex.Size + StylingIndex.SingleStylesStartPosition;\n\n  // fill single and multi-level styles\n  for (let i = 0; i < totalProps; i++) {\n    const isClassBased = i >= classNamesIndexStart;\n    const prop = isClassBased ? classNames[i - classNamesIndexStart] : styleProps[i];\n    const indexForInitial = isClassBased ? classesLookup[prop] : stylesLookup[prop];\n    const initialValue = initialStylingValues[indexForInitial];\n\n    const indexForMulti = i * StylingIndex.Size + multiStart;\n    const indexForSingle = i * StylingIndex.Size + singleStart;\n    const initialFlag = prepareInitialFlag(prop, isClassBased, styleSanitizer || null);\n\n    setFlag(context, indexForSingle, pointers(initialFlag, indexForInitial, indexForMulti));\n    setProp(context, indexForSingle, prop);\n    setValue(context, indexForSingle, null);\n    setPlayerBuilderIndex(context, indexForSingle, 0);\n\n    const flagForMulti =\n        initialFlag | (initialValue !== null ? StylingFlags.Dirty : StylingFlags.None);\n    setFlag(context, indexForMulti, pointers(flagForMulti, indexForInitial, indexForSingle));\n    setProp(context, indexForMulti, prop);\n    setValue(context, indexForMulti, null);\n    setPlayerBuilderIndex(context, indexForMulti, 0);\n  }\n\n  // there is no initial value flag for the master index since it doesn't\n  // reference an initial style value\n  const masterFlag = pointers(0, 0, multiStart) |\n      (onlyProcessSingleClasses ? StylingFlags.OnlyProcessSingleClasses : 0);\n  setFlag(context, StylingIndex.MasterFlagPosition, masterFlag);\n  setContextDirty(context, initialStylingValues.length > 1);\n\n  if (initialStaticClasses) {\n    context[StylingIndex.PreviousOrCachedMultiClassValue] = initialStaticClasses.join(' ');\n  }\n\n  return context;\n}\n\n/**\n * Sets and resolves all `multi` styling on an `StylingContext` so that they can be\n * applied to the element once `renderStyleAndClassBindings` is called.\n *\n * All missing styles/class (any values that are not provided in the new `styles`\n * or `classes` params) will resolve to `null` within their respective positions\n * in the context.\n *\n * @param context The styling context that will be updated with the\n *    newly provided style values.\n * @param classesInput The key/value map of CSS class names that will be used for the update.\n * @param stylesInput The key/value map of CSS styles that will be used for the update.\n */\nexport function updateStylingMap(\n    context: StylingContext, classesInput: {[key: string]: any} | string |\n        BoundPlayerFactory<null|string|{[key: string]: any}>| NO_CHANGE | null,\n    stylesInput?: {[key: string]: any} | BoundPlayerFactory<null|{[key: string]: any}>| NO_CHANGE |\n        null): void {\n  stylesInput = stylesInput || null;\n\n  const element = context[StylingIndex.ElementPosition] !as HTMLElement;\n  const classesPlayerBuilder = classesInput instanceof BoundPlayerFactory ?\n      new ClassAndStylePlayerBuilder(classesInput as any, element, BindingType.Class) :\n      null;\n  const stylesPlayerBuilder = stylesInput instanceof BoundPlayerFactory ?\n      new ClassAndStylePlayerBuilder(stylesInput as any, element, BindingType.Style) :\n      null;\n\n  const classesValue = classesPlayerBuilder ?\n      (classesInput as BoundPlayerFactory<{[key: string]: any}|string>) !.value :\n      classesInput;\n  const stylesValue = stylesPlayerBuilder ? stylesInput !.value : stylesInput;\n  // early exit (this is what's done to avoid using ctx.bind() to cache the value)\n  const ignoreAllClassUpdates = limitToSingleClasses(context) || classesValue === NO_CHANGE ||\n      classesValue === context[StylingIndex.PreviousOrCachedMultiClassValue];\n  const ignoreAllStyleUpdates =\n      stylesValue === NO_CHANGE || stylesValue === context[StylingIndex.PreviousMultiStyleValue];\n  if (ignoreAllClassUpdates && ignoreAllStyleUpdates) return;\n\n  context[StylingIndex.PreviousOrCachedMultiClassValue] = classesValue;\n  context[StylingIndex.PreviousMultiStyleValue] = stylesValue;\n\n  let classNames: string[] = EMPTY_ARR;\n  let applyAllClasses = false;\n  let playerBuildersAreDirty = false;\n\n  const classesPlayerBuilderIndex =\n      classesPlayerBuilder ? PlayerIndex.ClassMapPlayerBuilderPosition : 0;\n  if (hasPlayerBuilderChanged(\n          context, classesPlayerBuilder, PlayerIndex.ClassMapPlayerBuilderPosition)) {\n    setPlayerBuilder(context, classesPlayerBuilder, PlayerIndex.ClassMapPlayerBuilderPosition);\n    playerBuildersAreDirty = true;\n  }\n\n  const stylesPlayerBuilderIndex =\n      stylesPlayerBuilder ? PlayerIndex.StyleMapPlayerBuilderPosition : 0;\n  if (hasPlayerBuilderChanged(\n          context, stylesPlayerBuilder, PlayerIndex.StyleMapPlayerBuilderPosition)) {\n    setPlayerBuilder(context, stylesPlayerBuilder, PlayerIndex.StyleMapPlayerBuilderPosition);\n    playerBuildersAreDirty = true;\n  }\n\n  // each time a string-based value pops up then it shouldn't require a deep\n  // check of what's changed.\n  if (!ignoreAllClassUpdates) {\n    if (typeof classesValue == 'string') {\n      classNames = classesValue.split(/\\s+/);\n      // this boolean is used to avoid having to create a key/value map of `true` values\n      // since a classname string implies that all those classes are added\n      applyAllClasses = true;\n    } else {\n      classNames = classesValue ? Object.keys(classesValue) : EMPTY_ARR;\n    }\n  }\n\n  const classes = (classesValue || EMPTY_OBJ) as{[key: string]: any};\n  const styleProps = stylesValue ? Object.keys(stylesValue) : EMPTY_ARR;\n  const styles = stylesValue || EMPTY_OBJ;\n\n  const classesStartIndex = styleProps.length;\n  const multiStartIndex = getMultiStartIndex(context);\n\n  let dirty = false;\n  let ctxIndex = multiStartIndex;\n\n  let propIndex = 0;\n  const propLimit = styleProps.length + classNames.length;\n\n  // the main loop here will try and figure out how the shape of the provided\n  // styles differ with respect to the context. Later if the context/styles/classes\n  // are off-balance then they will be dealt in another loop after this one\n  while (ctxIndex < context.length && propIndex < propLimit) {\n    const isClassBased = propIndex >= classesStartIndex;\n    const processValue =\n        (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);\n\n    // when there is a cache-hit for a string-based class then we should\n    // avoid doing any work diffing any of the changes\n    if (processValue) {\n      const adjustedPropIndex = isClassBased ? propIndex - classesStartIndex : propIndex;\n      const newProp: string =\n          isClassBased ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];\n      const newValue: string|boolean =\n          isClassBased ? (applyAllClasses ? true : classes[newProp]) : styles[newProp];\n      const playerBuilderIndex =\n          isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n\n      const prop = getProp(context, ctxIndex);\n      if (prop === newProp) {\n        const value = getValue(context, ctxIndex);\n        const flag = getPointers(context, ctxIndex);\n        setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex);\n\n        if (hasValueChanged(flag, value, newValue)) {\n          setValue(context, ctxIndex, newValue);\n          playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n\n          const initialValue = getInitialValue(context, flag);\n\n          // there is no point in setting this to dirty if the previously\n          // rendered value was being referenced by the initial style (or null)\n          if (hasValueChanged(flag, initialValue, newValue)) {\n            setDirty(context, ctxIndex, true);\n            dirty = true;\n          }\n        }\n      } else {\n        const indexOfEntry = findEntryPositionByProp(context, newProp, ctxIndex);\n        if (indexOfEntry > 0) {\n          // it was found at a later point ... just swap the values\n          const valueToCompare = getValue(context, indexOfEntry);\n          const flagToCompare = getPointers(context, indexOfEntry);\n          swapMultiContextEntries(context, ctxIndex, indexOfEntry);\n          if (hasValueChanged(flagToCompare, valueToCompare, newValue)) {\n            const initialValue = getInitialValue(context, flagToCompare);\n            setValue(context, ctxIndex, newValue);\n            if (hasValueChanged(flagToCompare, initialValue, newValue)) {\n              setDirty(context, ctxIndex, true);\n              playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n              dirty = true;\n            }\n          }\n        } else {\n          // we only care to do this if the insertion is in the middle\n          const newFlag = prepareInitialFlag(newProp, isClassBased, getStyleSanitizer(context));\n          playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n          insertNewMultiProperty(\n              context, ctxIndex, isClassBased, newProp, newFlag, newValue, playerBuilderIndex);\n          dirty = true;\n        }\n      }\n    }\n\n    ctxIndex += StylingIndex.Size;\n    propIndex++;\n  }\n\n  // this means that there are left-over values in the context that\n  // were not included in the provided styles/classes and in this\n  // case the  goal is to \"remove\" them from the context (by nullifying)\n  while (ctxIndex < context.length) {\n    const flag = getPointers(context, ctxIndex);\n    const isClassBased = (flag & StylingFlags.Class) === StylingFlags.Class;\n    const processValue =\n        (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);\n    if (processValue) {\n      const value = getValue(context, ctxIndex);\n      const doRemoveValue = valueExists(value, isClassBased);\n      if (doRemoveValue) {\n        setDirty(context, ctxIndex, true);\n        setValue(context, ctxIndex, null);\n\n        // we keep the player factory the same so that the `nulled` value can\n        // be instructed into the player because removing a style and/or a class\n        // is a valid animation player instruction.\n        const playerBuilderIndex =\n            isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n        setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex);\n        dirty = true;\n      }\n    }\n    ctxIndex += StylingIndex.Size;\n  }\n\n  // this means that there are left-over properties in the context that\n  // were not detected in the context during the loop above. In that\n  // case we want to add the new entries into the list\n  const sanitizer = getStyleSanitizer(context);\n  while (propIndex < propLimit) {\n    const isClassBased = propIndex >= classesStartIndex;\n    const processValue =\n        (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);\n    if (processValue) {\n      const adjustedPropIndex = isClassBased ? propIndex - classesStartIndex : propIndex;\n      const prop = isClassBased ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];\n      const value: string|boolean =\n          isClassBased ? (applyAllClasses ? true : classes[prop]) : styles[prop];\n      const flag = prepareInitialFlag(prop, isClassBased, sanitizer) | StylingFlags.Dirty;\n      const playerBuilderIndex =\n          isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n      context.push(flag, prop, value, playerBuilderIndex);\n      dirty = true;\n    }\n    propIndex++;\n  }\n\n  if (dirty) {\n    setContextDirty(context, true);\n  }\n\n  if (playerBuildersAreDirty) {\n    setContextPlayersDirty(context, true);\n  }\n}\n\n/**\n * Sets and resolves a single styling property/value on the provided `StylingContext` so\n * that they can be applied to the element once `renderStyleAndClassBindings` is called.\n *\n * Note that prop-level styling values are considered higher priority than any styling that\n * has been applied using `updateStylingMap`, therefore, when styling values are rendered\n * then any styles/classes that have been applied using this function will be considered first\n * (then multi values second and then initial values as a backup).\n *\n * @param context The styling context that will be updated with the\n *    newly provided style value.\n * @param index The index of the property which is being updated.\n * @param value The CSS style value that will be assigned\n */\nexport function updateStyleProp(\n    context: StylingContext, index: number,\n    input: string | boolean | null | BoundPlayerFactory<string|boolean|null>): void {\n  const singleIndex = StylingIndex.SingleStylesStartPosition + index * StylingIndex.Size;\n  const currValue = getValue(context, singleIndex);\n  const currFlag = getPointers(context, singleIndex);\n  const value: string|boolean|null = (input instanceof BoundPlayerFactory) ? input.value : input;\n\n  // didn't change ... nothing to make a note of\n  if (hasValueChanged(currFlag, currValue, value)) {\n    const isClassBased = (currFlag & StylingFlags.Class) === StylingFlags.Class;\n    const element = context[StylingIndex.ElementPosition] !as HTMLElement;\n    const playerBuilder = input instanceof BoundPlayerFactory ?\n        new ClassAndStylePlayerBuilder(\n            input as any, element, isClassBased ? BindingType.Class : BindingType.Style) :\n        null;\n    const value = (playerBuilder ? (input as BoundPlayerFactory<any>).value : input) as string |\n        boolean | null;\n    const currPlayerIndex = getPlayerBuilderIndex(context, singleIndex);\n\n    let playerBuildersAreDirty = false;\n    let playerBuilderIndex = playerBuilder ? currPlayerIndex : 0;\n    if (hasPlayerBuilderChanged(context, playerBuilder, currPlayerIndex)) {\n      const newIndex = setPlayerBuilder(context, playerBuilder, currPlayerIndex);\n      playerBuilderIndex = playerBuilder ? newIndex : 0;\n      setPlayerBuilderIndex(context, singleIndex, playerBuilderIndex);\n      playerBuildersAreDirty = true;\n    }\n\n    // the value will always get updated (even if the dirty flag is skipped)\n    setValue(context, singleIndex, value);\n    const indexForMulti = getMultiOrSingleIndex(currFlag);\n\n    // if the value is the same in the multi-area then there's no point in re-assembling\n    const valueForMulti = getValue(context, indexForMulti);\n    if (!valueForMulti || hasValueChanged(currFlag, valueForMulti, value)) {\n      let multiDirty = false;\n      let singleDirty = true;\n\n      // only when the value is set to `null` should the multi-value get flagged\n      if (!valueExists(value, isClassBased) && valueExists(valueForMulti, isClassBased)) {\n        multiDirty = true;\n        singleDirty = false;\n      }\n\n      setDirty(context, indexForMulti, multiDirty);\n      setDirty(context, singleIndex, singleDirty);\n      setContextDirty(context, true);\n    }\n\n    if (playerBuildersAreDirty) {\n      setContextPlayersDirty(context, true);\n    }\n  }\n}\n\n/**\n * This method will toggle the referenced CSS class (by the provided index)\n * within the given context.\n *\n * @param context The styling context that will be updated with the\n *    newly provided class value.\n * @param index The index of the CSS class which is being updated.\n * @param addOrRemove Whether or not to add or remove the CSS class\n */\nexport function updateClassProp(\n    context: StylingContext, index: number,\n    addOrRemove: boolean | BoundPlayerFactory<boolean>): void {\n  const adjustedIndex = index + context[StylingIndex.ClassOffsetPosition];\n  updateStyleProp(context, adjustedIndex, addOrRemove);\n}\n\n/**\n * Renders all queued styling using a renderer onto the given element.\n *\n * This function works by rendering any styles (that have been applied\n * using `updateStylingMap`) and any classes (that have been applied using\n * `updateStyleProp`) onto the provided element using the provided renderer.\n * Just before the styles/classes are rendered a final key/value style map\n * will be assembled (if `styleStore` or `classStore` are provided).\n *\n * @param lElement the element that the styles will be rendered on\n * @param context The styling context that will be used to determine\n *      what styles will be rendered\n * @param renderer the renderer that will be used to apply the styling\n * @param classesStore if provided, the updated class values will be applied\n *    to this key/value map instead of being renderered via the renderer.\n * @param stylesStore if provided, the updated style values will be applied\n *    to this key/value map instead of being renderered via the renderer.\n * @returns number the total amount of players that got queued for animation (if any)\n */\nexport function renderStyleAndClassBindings(\n    context: StylingContext, renderer: Renderer3, rootOrView: RootContext | LViewData,\n    isFirstRender: boolean, classesStore?: BindingStore | null,\n    stylesStore?: BindingStore | null): number {\n  let totalPlayersQueued = 0;\n\n  if (isContextDirty(context)) {\n    const flushPlayerBuilders: any =\n        context[StylingIndex.MasterFlagPosition] & StylingFlags.PlayerBuildersDirty;\n    const native = context[StylingIndex.ElementPosition] !;\n    const multiStartIndex = getMultiStartIndex(context);\n    const styleSanitizer = getStyleSanitizer(context);\n    const onlySingleClasses = limitToSingleClasses(context);\n\n    for (let i = StylingIndex.SingleStylesStartPosition; i < context.length;\n         i += StylingIndex.Size) {\n      // there is no point in rendering styles that have not changed on screen\n      if (isDirty(context, i)) {\n        const prop = getProp(context, i);\n        const value = getValue(context, i);\n        const flag = getPointers(context, i);\n        const playerBuilder = getPlayerBuilder(context, i);\n        const isClassBased = flag & StylingFlags.Class ? true : false;\n        const isInSingleRegion = i < multiStartIndex;\n        const readInitialValue = !isClassBased || !onlySingleClasses;\n\n        let valueToApply: string|boolean|null = value;\n\n        // VALUE DEFER CASE 1: Use a multi value instead of a null single value\n        // this check implies that a single value was removed and we\n        // should now defer to a multi value and use that (if set).\n        if (isInSingleRegion && !valueExists(valueToApply, isClassBased)) {\n          // single values ALWAYS have a reference to a multi index\n          const multiIndex = getMultiOrSingleIndex(flag);\n          valueToApply = getValue(context, multiIndex);\n        }\n\n        // VALUE DEFER CASE 2: Use the initial value if all else fails (is falsy)\n        // the initial value will always be a string or null,\n        // therefore we can safely adopt it incase there's nothing else\n        // note that this should always be a falsy check since `false` is used\n        // for both class and style comparisons (styles can't be false and false\n        // classes are turned off and should therefore defer to their initial values)\n        if (!valueExists(valueToApply, isClassBased) && readInitialValue) {\n          valueToApply = getInitialValue(context, flag);\n        }\n\n        // if the first render is true then we do not want to start applying falsy\n        // values to the DOM element's styling. Otherwise then we know there has\n        // been a change and even if it's falsy then it's removing something that\n        // was truthy before.\n        const doApplyValue = isFirstRender ? valueToApply : true;\n        if (doApplyValue) {\n          if (isClassBased) {\n            setClass(\n                native, prop, valueToApply ? true : false, renderer, classesStore, playerBuilder);\n          } else {\n            const sanitizer = (flag & StylingFlags.Sanitize) ? styleSanitizer : null;\n            setStyle(\n                native, prop, valueToApply as string | null, renderer, sanitizer, stylesStore,\n                playerBuilder);\n          }\n        }\n\n        setDirty(context, i, false);\n      }\n    }\n\n    if (flushPlayerBuilders) {\n      const rootContext =\n          Array.isArray(rootOrView) ? getRootContext(rootOrView) : rootOrView as RootContext;\n      const playerContext = getPlayerContext(context) !;\n      const playersStartIndex = playerContext[PlayerIndex.NonBuilderPlayersStart];\n      for (let i = PlayerIndex.PlayerBuildersStartPosition; i < playersStartIndex;\n           i += PlayerIndex.PlayerAndPlayerBuildersTupleSize) {\n        const builder = playerContext[i] as ClassAndStylePlayerBuilder<any>| null;\n        const playerInsertionIndex = i + PlayerIndex.PlayerOffsetPosition;\n        const oldPlayer = playerContext[playerInsertionIndex] as Player | null;\n        if (builder) {\n          const player = builder.buildPlayer(oldPlayer, isFirstRender);\n          if (player !== undefined) {\n            if (player != null) {\n              const wasQueued = addPlayerInternal(\n                  playerContext, rootContext, native as HTMLElement, player, playerInsertionIndex);\n              wasQueued && totalPlayersQueued++;\n            }\n            if (oldPlayer) {\n              oldPlayer.destroy();\n            }\n          }\n        } else if (oldPlayer) {\n          // the player builder has been removed ... therefore we should delete the associated\n          // player\n          oldPlayer.destroy();\n        }\n      }\n      setContextPlayersDirty(context, false);\n    }\n    setContextDirty(context, false);\n  }\n\n  return totalPlayersQueued;\n}\n\n/**\n * This function renders a given CSS prop/value entry using the\n * provided renderer. If a `store` value is provided then\n * that will be used a render context instead of the provided\n * renderer.\n *\n * @param native the DOM Element\n * @param prop the CSS style property that will be rendered\n * @param value the CSS style value that will be rendered\n * @param renderer\n * @param store an optional key/value map that will be used as a context to render styles on\n */\nfunction setStyle(\n    native: any, prop: string, value: string | null, renderer: Renderer3,\n    sanitizer: StyleSanitizeFn | null, store?: BindingStore | null,\n    playerBuilder?: ClassAndStylePlayerBuilder<any>| null) {\n  value = sanitizer && value ? sanitizer(prop, value) : value;\n  if (store || playerBuilder) {\n    if (store) {\n      store.setValue(prop, value);\n    }\n    if (playerBuilder) {\n      playerBuilder.setValue(prop, value);\n    }\n  } else if (value) {\n    ngDevMode && ngDevMode.rendererSetStyle++;\n    isProceduralRenderer(renderer) ?\n        renderer.setStyle(native, prop, value, RendererStyleFlags3.DashCase) :\n        native['style'].setProperty(prop, value);\n  } else {\n    ngDevMode && ngDevMode.rendererRemoveStyle++;\n    isProceduralRenderer(renderer) ?\n        renderer.removeStyle(native, prop, RendererStyleFlags3.DashCase) :\n        native['style'].removeProperty(prop);\n  }\n}\n\n/**\n * This function renders a given CSS class value using the provided\n * renderer (by adding or removing it from the provided element).\n * If a `store` value is provided then that will be used a render\n * context instead of the provided renderer.\n *\n * @param native the DOM Element\n * @param prop the CSS style property that will be rendered\n * @param value the CSS style value that will be rendered\n * @param renderer\n * @param store an optional key/value map that will be used as a context to render styles on\n */\nfunction setClass(\n    native: any, className: string, add: boolean, renderer: Renderer3, store?: BindingStore | null,\n    playerBuilder?: ClassAndStylePlayerBuilder<any>| null) {\n  if (store || playerBuilder) {\n    if (store) {\n      store.setValue(className, add);\n    }\n    if (playerBuilder) {\n      playerBuilder.setValue(className, add);\n    }\n  } else if (add) {\n    ngDevMode && ngDevMode.rendererAddClass++;\n    isProceduralRenderer(renderer) ? renderer.addClass(native, className) :\n                                     native['classList'].add(className);\n  } else {\n    ngDevMode && ngDevMode.rendererRemoveClass++;\n    isProceduralRenderer(renderer) ? renderer.removeClass(native, className) :\n                                     native['classList'].remove(className);\n  }\n}\n\nfunction setDirty(context: StylingContext, index: number, isDirtyYes: boolean) {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  if (isDirtyYes) {\n    (context[adjustedIndex] as number) |= StylingFlags.Dirty;\n  } else {\n    (context[adjustedIndex] as number) &= ~StylingFlags.Dirty;\n  }\n}\n\nfunction isDirty(context: StylingContext, index: number): boolean {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  return ((context[adjustedIndex] as number) & StylingFlags.Dirty) == StylingFlags.Dirty;\n}\n\nfunction isClassBased(context: StylingContext, index: number): boolean {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  return ((context[adjustedIndex] as number) & StylingFlags.Class) == StylingFlags.Class;\n}\n\nfunction isSanitizable(context: StylingContext, index: number): boolean {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  return ((context[adjustedIndex] as number) & StylingFlags.Sanitize) == StylingFlags.Sanitize;\n}\n\nfunction pointers(configFlag: number, staticIndex: number, dynamicIndex: number) {\n  return (configFlag & StylingFlags.BitMask) | (staticIndex << StylingFlags.BitCountSize) |\n      (dynamicIndex << (StylingIndex.BitCountSize + StylingFlags.BitCountSize));\n}\n\nfunction getInitialValue(context: StylingContext, flag: number): string|null {\n  const index = getInitialIndex(flag);\n  return context[StylingIndex.InitialStylesPosition][index] as null | string;\n}\n\nfunction getInitialIndex(flag: number): number {\n  return (flag >> StylingFlags.BitCountSize) & StylingIndex.BitMask;\n}\n\nfunction getMultiOrSingleIndex(flag: number): number {\n  const index =\n      (flag >> (StylingIndex.BitCountSize + StylingFlags.BitCountSize)) & StylingIndex.BitMask;\n  return index >= StylingIndex.SingleStylesStartPosition ? index : -1;\n}\n\nfunction getMultiStartIndex(context: StylingContext): number {\n  return getMultiOrSingleIndex(context[StylingIndex.MasterFlagPosition]) as number;\n}\n\nfunction getStyleSanitizer(context: StylingContext): StyleSanitizeFn|null {\n  return context[StylingIndex.StyleSanitizerPosition];\n}\n\nfunction setProp(context: StylingContext, index: number, prop: string) {\n  context[index + StylingIndex.PropertyOffset] = prop;\n}\n\nfunction setValue(context: StylingContext, index: number, value: string | null | boolean) {\n  context[index + StylingIndex.ValueOffset] = value;\n}\n\nfunction hasPlayerBuilderChanged(\n    context: StylingContext, builder: ClassAndStylePlayerBuilder<any>| null, index: number) {\n  const playerContext = context[StylingIndex.PlayerContext] !;\n  if (builder) {\n    if (!playerContext || index === 0) {\n      return true;\n    }\n  } else if (!playerContext) {\n    return false;\n  }\n  return playerContext[index] !== builder;\n}\n\nfunction setPlayerBuilder(\n    context: StylingContext, builder: ClassAndStylePlayerBuilder<any>| null,\n    insertionIndex: number): number {\n  let playerContext = context[StylingIndex.PlayerContext] || allocPlayerContext(context);\n  if (insertionIndex > 0) {\n    playerContext[insertionIndex] = builder;\n  } else {\n    insertionIndex = playerContext[PlayerIndex.NonBuilderPlayersStart];\n    playerContext.splice(insertionIndex, 0, builder, null);\n    playerContext[PlayerIndex.NonBuilderPlayersStart] +=\n        PlayerIndex.PlayerAndPlayerBuildersTupleSize;\n  }\n  return insertionIndex;\n}\n\nfunction setPlayerBuilderIndex(context: StylingContext, index: number, playerBuilderIndex: number) {\n  context[index + StylingIndex.PlayerBuilderIndexOffset] = playerBuilderIndex;\n}\n\nfunction getPlayerBuilderIndex(context: StylingContext, index: number): number {\n  return (context[index + StylingIndex.PlayerBuilderIndexOffset] as number) || 0;\n}\n\nfunction getPlayerBuilder(context: StylingContext, index: number): ClassAndStylePlayerBuilder<any>|\n    null {\n  const playerBuilderIndex = getPlayerBuilderIndex(context, index);\n  if (playerBuilderIndex) {\n    const playerContext = context[StylingIndex.PlayerContext];\n    if (playerContext) {\n      return playerContext[playerBuilderIndex] as ClassAndStylePlayerBuilder<any>| null;\n    }\n  }\n  return null;\n}\n\nfunction setFlag(context: StylingContext, index: number, flag: number) {\n  const adjustedIndex =\n      index === StylingIndex.MasterFlagPosition ? index : (index + StylingIndex.FlagsOffset);\n  context[adjustedIndex] = flag;\n}\n\nfunction getPointers(context: StylingContext, index: number): number {\n  const adjustedIndex =\n      index === StylingIndex.MasterFlagPosition ? index : (index + StylingIndex.FlagsOffset);\n  return context[adjustedIndex] as number;\n}\n\nfunction getValue(context: StylingContext, index: number): string|boolean|null {\n  return context[index + StylingIndex.ValueOffset] as string | boolean | null;\n}\n\nfunction getProp(context: StylingContext, index: number): string {\n  return context[index + StylingIndex.PropertyOffset] as string;\n}\n\nexport function isContextDirty(context: StylingContext): boolean {\n  return isDirty(context, StylingIndex.MasterFlagPosition);\n}\n\nexport function limitToSingleClasses(context: StylingContext) {\n  return context[StylingIndex.MasterFlagPosition] & StylingFlags.OnlyProcessSingleClasses;\n}\n\nexport function setContextDirty(context: StylingContext, isDirtyYes: boolean): void {\n  setDirty(context, StylingIndex.MasterFlagPosition, isDirtyYes);\n}\n\nexport function setContextPlayersDirty(context: StylingContext, isDirtyYes: boolean): void {\n  if (isDirtyYes) {\n    (context[StylingIndex.MasterFlagPosition] as number) |= StylingFlags.PlayerBuildersDirty;\n  } else {\n    (context[StylingIndex.MasterFlagPosition] as number) &= ~StylingFlags.PlayerBuildersDirty;\n  }\n}\n\nfunction findEntryPositionByProp(\n    context: StylingContext, prop: string, startIndex?: number): number {\n  for (let i = (startIndex || 0) + StylingIndex.PropertyOffset; i < context.length;\n       i += StylingIndex.Size) {\n    const thisProp = context[i];\n    if (thisProp == prop) {\n      return i - StylingIndex.PropertyOffset;\n    }\n  }\n  return -1;\n}\n\nfunction swapMultiContextEntries(context: StylingContext, indexA: number, indexB: number) {\n  const tmpValue = getValue(context, indexA);\n  const tmpProp = getProp(context, indexA);\n  const tmpFlag = getPointers(context, indexA);\n  const tmpPlayerBuilderIndex = getPlayerBuilderIndex(context, indexA);\n\n  let flagA = tmpFlag;\n  let flagB = getPointers(context, indexB);\n\n  const singleIndexA = getMultiOrSingleIndex(flagA);\n  if (singleIndexA >= 0) {\n    const _flag = getPointers(context, singleIndexA);\n    const _initial = getInitialIndex(_flag);\n    setFlag(context, singleIndexA, pointers(_flag, _initial, indexB));\n  }\n\n  const singleIndexB = getMultiOrSingleIndex(flagB);\n  if (singleIndexB >= 0) {\n    const _flag = getPointers(context, singleIndexB);\n    const _initial = getInitialIndex(_flag);\n    setFlag(context, singleIndexB, pointers(_flag, _initial, indexA));\n  }\n\n  setValue(context, indexA, getValue(context, indexB));\n  setProp(context, indexA, getProp(context, indexB));\n  setFlag(context, indexA, getPointers(context, indexB));\n  setPlayerBuilderIndex(context, indexA, getPlayerBuilderIndex(context, indexB));\n\n  setValue(context, indexB, tmpValue);\n  setProp(context, indexB, tmpProp);\n  setFlag(context, indexB, tmpFlag);\n  setPlayerBuilderIndex(context, indexB, tmpPlayerBuilderIndex);\n}\n\nfunction updateSinglePointerValues(context: StylingContext, indexStartPosition: number) {\n  for (let i = indexStartPosition; i < context.length; i += StylingIndex.Size) {\n    const multiFlag = getPointers(context, i);\n    const singleIndex = getMultiOrSingleIndex(multiFlag);\n    if (singleIndex > 0) {\n      const singleFlag = getPointers(context, singleIndex);\n      const initialIndexForSingle = getInitialIndex(singleFlag);\n      const flagValue = (isDirty(context, singleIndex) ? StylingFlags.Dirty : StylingFlags.None) |\n          (isClassBased(context, singleIndex) ? StylingFlags.Class : StylingFlags.None) |\n          (isSanitizable(context, singleIndex) ? StylingFlags.Sanitize : StylingFlags.None);\n      const updatedFlag = pointers(flagValue, initialIndexForSingle, i);\n      setFlag(context, singleIndex, updatedFlag);\n    }\n  }\n}\n\nfunction insertNewMultiProperty(\n    context: StylingContext, index: number, classBased: boolean, name: string, flag: number,\n    value: string | boolean, playerIndex: number): void {\n  const doShift = index < context.length;\n\n  // prop does not exist in the list, add it in\n  context.splice(\n      index, 0, flag | StylingFlags.Dirty | (classBased ? StylingFlags.Class : StylingFlags.None),\n      name, value, playerIndex);\n\n  if (doShift) {\n    // because the value was inserted midway into the array then we\n    // need to update all the shifted multi values' single value\n    // pointers to point to the newly shifted location\n    updateSinglePointerValues(context, index + StylingIndex.Size);\n  }\n}\n\nfunction valueExists(value: string | null | boolean, isClassBased?: boolean) {\n  if (isClassBased) {\n    return value ? true : false;\n  }\n  return value !== null;\n}\n\nfunction prepareInitialFlag(\n    name: string, isClassBased: boolean, sanitizer?: StyleSanitizeFn | null) {\n  if (isClassBased) {\n    return StylingFlags.Class;\n  } else if (sanitizer && sanitizer(name)) {\n    return StylingFlags.Sanitize;\n  }\n  return StylingFlags.None;\n}\n\nfunction hasValueChanged(\n    flag: number, a: string | boolean | null, b: string | boolean | null): boolean {\n  const isClassBased = flag & StylingFlags.Class;\n  const hasValues = a && b;\n  const usesSanitizer = flag & StylingFlags.Sanitize;\n  // the toString() comparison ensures that a value is checked\n  // ... otherwise (during sanitization bypassing) the === comparsion\n  // would fail since a new String() instance is created\n  if (!isClassBased && hasValues && usesSanitizer) {\n    // we know for sure we're dealing with strings at this point\n    return (a as string).toString() !== (b as string).toString();\n  }\n\n  // everything else is safe to check with a normal equality check\n  return a !== b;\n}\n\nexport class ClassAndStylePlayerBuilder<T> implements PlayerBuilder {\n  private _values: {[key: string]: string | null} = {};\n  private _dirty = false;\n  private _factory: BoundPlayerFactory<T>;\n\n  constructor(factory: PlayerFactory, private _element: HTMLElement, private _type: BindingType) {\n    this._factory = factory as any;\n  }\n\n  setValue(prop: string, value: any) {\n    if (this._values[prop] !== value) {\n      this._values[prop] = value;\n      this._dirty = true;\n    }\n  }\n\n  buildPlayer(currentPlayer: Player|null, isFirstRender: boolean): Player|undefined|null {\n    // if no values have been set here then this means the binding didn't\n    // change and therefore the binding values were not updated through\n    // `setValue` which means no new player will be provided.\n    if (this._dirty) {\n      const player = this._factory.fn(\n          this._element, this._type, this._values !, isFirstRender, currentPlayer || null);\n      this._values = {};\n      this._dirty = false;\n      return player;\n    }\n\n    return undefined;\n  }\n}\n"]}
+/**
+ * Used to provide a summary of the state of the styling context.
+ *
+ * This is an internal interface that is only used inside of test tooling to
+ * help summarize what's going on within the styling context. None of this code
+ * is designed to be exported publicly and will, therefore, be tree-shaken away
+ * during runtime.
+ * @record
+ */
+export function LogSummary() { }
+if (false) {
+    /** @type {?} */
+    LogSummary.prototype.name;
+    /** @type {?} */
+    LogSummary.prototype.staticIndex;
+    /** @type {?} */
+    LogSummary.prototype.dynamicIndex;
+    /** @type {?} */
+    LogSummary.prototype.value;
+    /** @type {?} */
+    LogSummary.prototype.flags;
+}
+/**
+ * @param {?} source
+ * @param {?=} index
+ * @return {?}
+ */
+export function generateConfigSummary(source, index) {
+    /** @type {?} */
+    let flag;
+    /** @type {?} */
+    let name = 'config value for ';
+    if (Array.isArray(source)) {
+        if (index) {
+            name += 'index: ' + index;
+        }
+        else {
+            name += 'master config';
+        }
+        index = index || 0 /* MasterFlagPosition */;
+        flag = (/** @type {?} */ (source[index]));
+    }
+    else {
+        flag = source;
+        name += 'index: ' + flag;
+    }
+    /** @type {?} */
+    const dynamicIndex = getMultiOrSingleIndex(flag);
+    /** @type {?} */
+    const staticIndex = getInitialIndex(flag);
+    return {
+        name,
+        staticIndex,
+        dynamicIndex,
+        value: flag,
+        flags: {
+            dirty: flag & 1 /* Dirty */ ? true : false,
+            class: flag & 2 /* Class */ ? true : false,
+            sanitize: flag & 4 /* Sanitize */ ? true : false,
+            playerBuildersDirty: flag & 8 /* PlayerBuildersDirty */ ? true : false,
+            onlyProcessSingleClasses: flag & 16 /* OnlyProcessSingleClasses */ ? true : false,
+            bindingAllocationLocked: flag & 32 /* BindingAllocationLocked */ ? true : false,
+        }
+    };
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function getDirectiveIndexFromEntry(context, index) {
+    /** @type {?} */
+    const value = (/** @type {?} */ (context[index + 3 /* PlayerBuilderIndexOffset */]));
+    return value & 65535 /* BitMask */;
+}
+/**
+ * @param {?} context
+ * @param {?} directive
+ * @return {?}
+ */
+function getDirectiveIndexFromRegistry(context, directive) {
+    /** @type {?} */
+    const index = getDirectiveRegistryValuesIndexOf(context[1 /* DirectiveRegistryPosition */], directive);
+    ngDevMode &&
+        assertNotEqual(index, -1, `The provided directive ${directive} has not been allocated to the element\'s style/class bindings`);
+    return index > 0 ? index / 4 /* Size */ : 0;
+    // return index / DirectiveRegistryValuesIndex.Size;
+}
+/**
+ * @param {?} directives
+ * @param {?} directive
+ * @return {?}
+ */
+function getDirectiveRegistryValuesIndexOf(directives, directive) {
+    for (let i = 0; i < directives.length; i += 4 /* Size */) {
+        if (directives[i] === directive) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * @param {?} keyValues
+ * @param {?} key
+ * @return {?}
+ */
+function getInitialStylingValuesIndexOf(keyValues, key) {
+    for (let i = 1 /* KeyValueStartPosition */; i < keyValues.length; i += 2 /* Size */) {
+        if (keyValues[i] === key)
+            return i;
+    }
+    return -1;
+}
+/**
+ * @param {?} a
+ * @param {?} b
+ * @return {?}
+ */
+export function compareLogSummaries(a, b) {
+    /** @type {?} */
+    const log = [];
+    /** @type {?} */
+    const diffs = [];
+    diffSummaryValues(diffs, 'staticIndex', 'staticIndex', a, b);
+    diffSummaryValues(diffs, 'dynamicIndex', 'dynamicIndex', a, b);
+    Object.keys(a.flags).forEach(name => { diffSummaryValues(diffs, 'flags.' + name, name, a.flags, b.flags); });
+    if (diffs.length) {
+        log.push('Log Summaries for:');
+        log.push('  A: ' + a.name);
+        log.push('  B: ' + b.name);
+        log.push('\n  Differ in the following way (A !== B):');
+        diffs.forEach(result => {
+            const [name, aVal, bVal] = result;
+            log.push('    => ' + name);
+            log.push('    => ' + aVal + ' !== ' + bVal + '\n');
+        });
+    }
+    return log;
+}
+/**
+ * @param {?} result
+ * @param {?} name
+ * @param {?} prop
+ * @param {?} a
+ * @param {?} b
+ * @return {?}
+ */
+function diffSummaryValues(result, name, prop, a, b) {
+    /** @type {?} */
+    const aVal = a[prop];
+    /** @type {?} */
+    const bVal = b[prop];
+    if (aVal !== bVal) {
+        result.push([name, aVal, bVal]);
+    }
+}
+/**
+ * @param {?} context
+ * @param {?} directiveIndex
+ * @param {?} offset
+ * @param {?} isClassBased
+ * @return {?}
+ */
+function getSinglePropIndexValue(context, directiveIndex, offset, isClassBased) {
+    /** @type {?} */
+    const singlePropOffsetRegistryIndex = (/** @type {?} */ (context[1 /* DirectiveRegistryPosition */][(directiveIndex * 4 /* Size */) +
+        1 /* SinglePropValuesIndexOffset */]));
+    /** @type {?} */
+    const offsets = context[4 /* SinglePropOffsetPositions */];
+    /** @type {?} */
+    const indexForOffset = singlePropOffsetRegistryIndex +
+        2 /* ValueStartPosition */ +
+        (isClassBased ?
+            offsets[singlePropOffsetRegistryIndex + 0 /* StylesCountPosition */] :
+            0) +
+        offset;
+    return offsets[indexForOffset];
+}
+/**
+ * @param {?} context
+ * @param {?} directiveIndex
+ * @return {?}
+ */
+function getStyleSanitizer(context, directiveIndex) {
+    /** @type {?} */
+    const dirs = context[1 /* DirectiveRegistryPosition */];
+    /** @type {?} */
+    const value = dirs[directiveIndex * 4 /* Size */ +
+        3 /* StyleSanitizerOffset */] ||
+        dirs[3 /* StyleSanitizerOffset */] || null;
+    return (/** @type {?} */ (value));
+}
+/**
+ * @param {?} context
+ * @param {?} directiveIndex
+ * @return {?}
+ */
+function isDirectiveDirty(context, directiveIndex) {
+    /** @type {?} */
+    const dirs = context[1 /* DirectiveRegistryPosition */];
+    return (/** @type {?} */ (dirs[directiveIndex * 4 /* Size */ +
+        2 /* DirtyFlagOffset */]));
+}
+/**
+ * @param {?} context
+ * @param {?} directiveIndex
+ * @param {?} dirtyYes
+ * @return {?}
+ */
+function setDirectiveDirty(context, directiveIndex, dirtyYes) {
+    /** @type {?} */
+    const dirs = context[1 /* DirectiveRegistryPosition */];
+    dirs[directiveIndex * 4 /* Size */ +
+        2 /* DirtyFlagOffset */] = dirtyYes;
+}
+/**
+ * @param {?} currentValue
+ * @param {?} newValue
+ * @param {?} currentDirectiveOwner
+ * @param {?} newDirectiveOwner
+ * @return {?}
+ */
+function allowValueChange(currentValue, newValue, currentDirectiveOwner, newDirectiveOwner) {
+    // the code below relies the importance of directive's being tied to their
+    // index value. The index values for each directive are derived from being
+    // registered into the styling context directive registry. The most important
+    // directive is the parent component directive (the template) and each directive
+    // that is added after is considered less important than the previous entry. This
+    // prioritization of directives enables the styling algorithm to decide if a style
+    // or class should be allowed to be updated/replaced incase an earlier directive
+    // already wrote to the exact same style-property or className value. In other words
+    // ... this decides what to do if and when there is a collision.
+    if (currentValue) {
+        if (newValue) {
+            // if a directive index is lower than it always has priority over the
+            // previous directive's value...
+            return newDirectiveOwner <= currentDirectiveOwner;
+        }
+        else {
+            // only write a null value incase it's the same owner writing it.
+            // this avoids having a higher-priority directive write to null
+            // only to have a lesser-priority directive change right to a
+            // non-null value immediately afterwards.
+            return currentDirectiveOwner === newDirectiveOwner;
+        }
+    }
+    return true;
+}
+/**
+ * This function is only designed to be called for `[class]` bindings when
+ * `[ngClass]` (or something that uses `class` as an input) is present. Once
+ * directive host bindings fully work for `[class]` and `[style]` inputs
+ * then this can be deleted.
+ * @param {?} context
+ * @return {?}
+ */
+export function getInitialClassNameValue(context) {
+    /** @type {?} */
+    let className = (/** @type {?} */ (context[6 /* CachedClassValueOrInitialClassString */]));
+    if (className == null) {
+        className = '';
+        /** @type {?} */
+        const initialClassValues = context[3 /* InitialClassValuesPosition */];
+        for (let i = 1 /* KeyValueStartPosition */; i < initialClassValues.length; i += 2 /* Size */) {
+            /** @type {?} */
+            const isPresent = initialClassValues[i + 1];
+            if (isPresent) {
+                className += (className.length ? ' ' : '') + initialClassValues[i];
+            }
+        }
+        context[6 /* CachedClassValueOrInitialClassString */] = className;
+    }
+    return className;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class_and_style_bindings.js","sourceRoot":"../../","sources":["packages/core/src/render3/styling/class_and_style_bindings.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {assertNotEqual} from '../assert';\nimport {EMPTY_ARRAY, EMPTY_OBJ} from '../empty';\nimport {AttributeMarker, TAttributes} from '../interfaces/node';\nimport {BindingStore, BindingType, Player, PlayerBuilder, PlayerFactory, PlayerIndex} from '../interfaces/player';\nimport {RElement, Renderer3, RendererStyleFlags3, isProceduralRenderer} from '../interfaces/renderer';\nimport {DirectiveOwnerAndPlayerBuilderIndex, DirectiveRegistryValues, DirectiveRegistryValuesIndex, InitialStylingValues, InitialStylingValuesIndex, SinglePropOffsetValues, SinglePropOffsetValuesIndex, StylingContext, StylingFlags, StylingIndex} from '../interfaces/styling';\nimport {LView, RootContext} from '../interfaces/view';\nimport {NO_CHANGE} from '../tokens';\nimport {getRootContext} from '../util';\n\nimport {BoundPlayerFactory} from './player_factory';\nimport {addPlayerInternal, allocPlayerContext, createEmptyStylingContext, getPlayerContext} from './util';\n\n\n/**\n * This file includes the code to power all styling-binding operations in Angular.\n *\n * These include:\n * [style]=\"myStyleObj\"\n * [class]=\"myClassObj\"\n * [style.prop]=\"myPropValue\"\n * [class.name]=\"myClassValue\"\n *\n * There are many different ways in which these functions below are called. Please see\n * `interfaces/styles.ts` to get a better idea of how the styling algorithm works.\n */\n\n\n\n/**\n * Creates a new StylingContext an fills it with the provided static styling attribute values.\n */\nexport function initializeStaticContext(attrs: TAttributes) {\n  const context = createEmptyStylingContext();\n  const initialClasses: InitialStylingValues = context[StylingIndex.InitialClassValuesPosition] =\n      [null];\n  const initialStyles: InitialStylingValues = context[StylingIndex.InitialStyleValuesPosition] =\n      [null];\n\n  // The attributes array has marker values (numbers) indicating what the subsequent\n  // values represent. When we encounter a number, we set the mode to that type of attribute.\n  let mode = -1;\n  for (let i = 0; i < attrs.length; i++) {\n    const attr = attrs[i];\n    if (typeof attr == 'number') {\n      mode = attr;\n    } else if (mode === AttributeMarker.Styles) {\n      initialStyles.push(attr as string, attrs[++i] as string);\n    } else if (mode === AttributeMarker.Classes) {\n      initialClasses.push(attr as string, true);\n    } else if (mode === AttributeMarker.SelectOnly) {\n      break;\n    }\n  }\n\n  return context;\n}\n\n/**\n * Designed to update an existing styling context with new static styling\n * data (classes and styles).\n *\n * @param context the existing styling context\n * @param attrs an array of new static styling attributes that will be\n *              assigned to the context\n * @param directive the directive instance with which static data is associated with.\n */\nexport function patchContextWithStaticAttrs(\n    context: StylingContext, attrs: TAttributes, directive: any): void {\n  // If the styling context has already been patched with the given directive's bindings,\n  // then there is no point in doing it again. The reason why this may happen (the directive\n  // styling being patched twice) is because the `stylingBinding` function is called each time\n  // an element is created (both within a template function and within directive host bindings).\n  const directives = context[StylingIndex.DirectiveRegistryPosition];\n  if (getDirectiveRegistryValuesIndexOf(directives, directive) == -1) {\n    // this is a new directive which we have not seen yet.\n    directives.push(directive, -1, false, null);\n\n    let initialClasses: InitialStylingValues|null = null;\n    let initialStyles: InitialStylingValues|null = null;\n\n    let mode = -1;\n    for (let i = 0; i < attrs.length; i++) {\n      const attr = attrs[i];\n      if (typeof attr == 'number') {\n        mode = attr;\n      } else if (mode == AttributeMarker.Classes) {\n        initialClasses = initialClasses || context[StylingIndex.InitialClassValuesPosition];\n        patchInitialStylingValue(initialClasses, attr, true);\n      } else if (mode == AttributeMarker.Styles) {\n        initialStyles = initialStyles || context[StylingIndex.InitialStyleValuesPosition];\n        patchInitialStylingValue(initialStyles, attr, attrs[++i]);\n      }\n    }\n  }\n}\n\n/**\n * Designed to add a style or class value into the existing set of initial styles.\n *\n * The function will search and figure out if a style/class value is already present\n * within the provided initial styling array. If and when a style/class value is not\n * present (or if it's value is falsy) then it will be inserted/updated in the list\n * of initial styling values.\n */\nfunction patchInitialStylingValue(\n    initialStyling: InitialStylingValues, prop: string, value: any): void {\n  // Even values are keys; Odd numbers are values; Search keys only\n  for (let i = InitialStylingValuesIndex.KeyValueStartPosition; i < initialStyling.length;) {\n    const key = initialStyling[i];\n    if (key === prop) {\n      const existingValue = initialStyling[i + InitialStylingValuesIndex.ValueOffset];\n\n      // If there is no previous style value (when `null`) or no previous class\n      // applied (when `false`) then we update the the newly given value.\n      if (existingValue == null || existingValue == false) {\n        initialStyling[i + InitialStylingValuesIndex.ValueOffset] = value;\n      }\n      return;\n    }\n    i = i + InitialStylingValuesIndex.Size;\n  }\n  // We did not find existing key, add a new one.\n  initialStyling.push(prop, value);\n}\n\n/**\n * Runs through the initial styling data present in the context and renders\n * them via the renderer on the element.\n */\nexport function renderInitialStylesAndClasses(\n    element: RElement, context: StylingContext, renderer: Renderer3) {\n  const initialClasses = context[StylingIndex.InitialClassValuesPosition];\n  renderInitialStylingValues(element, renderer, initialClasses, true);\n\n  const initialStyles = context[StylingIndex.InitialStyleValuesPosition];\n  renderInitialStylingValues(element, renderer, initialStyles, false);\n}\n\n/**\n * This is a helper function designed to render each entry present within the\n * provided list of initialStylingValues.\n */\nfunction renderInitialStylingValues(\n    element: RElement, renderer: Renderer3, initialStylingValues: InitialStylingValues,\n    isEntryClassBased: boolean) {\n  for (let i = InitialStylingValuesIndex.KeyValueStartPosition; i < initialStylingValues.length;\n       i += InitialStylingValuesIndex.Size) {\n    const value = initialStylingValues[i + InitialStylingValuesIndex.ValueOffset];\n    if (value) {\n      if (isEntryClassBased) {\n        setClass(\n            element, initialStylingValues[i + InitialStylingValuesIndex.PropOffset] as string, true,\n            renderer, null);\n      } else {\n        setStyle(\n            element, initialStylingValues[i + InitialStylingValuesIndex.PropOffset] as string,\n            value as string, renderer, null);\n      }\n    }\n  }\n}\n\nexport function allowNewBindingsForStylingContext(context: StylingContext): boolean {\n  return (context[StylingIndex.MasterFlagPosition] & StylingFlags.BindingAllocationLocked) === 0;\n}\n\n/**\n * Adds in new binding values to a styling context.\n *\n * If a directive value is provided then all provided class/style binding names will\n * reference the provided directive.\n *\n * @param context the existing styling context\n * @param directiveRef the directive that the new bindings will reference\n * @param classBindingNames an array of class binding names that will be added to the context\n * @param styleBindingNames an array of style binding names that will be added to the context\n * @param styleSanitizer an optional sanitizer that handle all sanitization on for each of\n *    the bindings added to the context. Note that if a directive is provided then the sanitizer\n *    instance will only be active if and when the directive updates the bindings that it owns.\n */\nexport function updateContextWithBindings(\n    context: StylingContext, directiveRef: any | null, classBindingNames?: string[] | null,\n    styleBindingNames?: string[] | null, styleSanitizer?: StyleSanitizeFn | null,\n    onlyProcessSingleClasses?: boolean) {\n  if (context[StylingIndex.MasterFlagPosition] & StylingFlags.BindingAllocationLocked) return;\n\n  // this means the context has already been patched with the directive's bindings\n  const directiveIndex = findOrPatchDirectiveIntoRegistry(context, directiveRef, styleSanitizer);\n  if (directiveIndex === -1) {\n    // this means the directive has already been patched in ... No point in doing anything\n    return;\n  }\n\n  // there are alot of variables being used below to track where in the context the new\n  // binding values will be placed. Because the context consists of multiple types of\n  // entries (single classes/styles and multi classes/styles) alot of the index positions\n  // need to be computed ahead of time and the context needs to be extended before the values\n  // are inserted in.\n  const singlePropOffsetValues = context[StylingIndex.SinglePropOffsetPositions];\n  const totalCurrentClassBindings =\n      singlePropOffsetValues[SinglePropOffsetValuesIndex.ClassesCountPosition];\n  const totalCurrentStyleBindings =\n      singlePropOffsetValues[SinglePropOffsetValuesIndex.StylesCountPosition];\n\n  const classesOffset = totalCurrentClassBindings * StylingIndex.Size;\n  const stylesOffset = totalCurrentStyleBindings * StylingIndex.Size;\n\n  const singleStylesStartIndex = StylingIndex.SingleStylesStartPosition;\n  let singleClassesStartIndex = singleStylesStartIndex + stylesOffset;\n  let multiStylesStartIndex = singleClassesStartIndex + classesOffset;\n  let multiClassesStartIndex = multiStylesStartIndex + stylesOffset;\n\n  // because we're inserting more bindings into the context, this means that the\n  // binding values need to be referenced the singlePropOffsetValues array so that\n  // the template/directive can easily find them inside of the `elementStyleProp`\n  // and the `elementClassProp` functions without iterating through the entire context.\n  // The first step to setting up these reference points is to mark how many bindings\n  // are being added. Even if these bindings already exist in the context, the directive\n  // or template code will still call them unknowingly. Therefore the total values need\n  // to be registered so that we know how many bindings are assigned to each directive.\n  const currentSinglePropsLength = singlePropOffsetValues.length;\n  singlePropOffsetValues.push(\n      styleBindingNames ? styleBindingNames.length : 0,\n      classBindingNames ? classBindingNames.length : 0);\n\n  // the code below will check to see if a new style binding already exists in the context\n  // if so then there is no point in inserting it into the context again. Whether or not it\n  // exists the styling offset code will now know exactly where it is\n  let insertionOffset = 0;\n  const filteredStyleBindingNames: string[] = [];\n  if (styleBindingNames && styleBindingNames.length) {\n    for (let i = 0; i < styleBindingNames.length; i++) {\n      const name = styleBindingNames[i];\n      let singlePropIndex =\n          getMatchingBindingIndex(context, name, singleStylesStartIndex, singleClassesStartIndex);\n      if (singlePropIndex == -1) {\n        singlePropIndex = singleClassesStartIndex + insertionOffset;\n        insertionOffset += StylingIndex.Size;\n        filteredStyleBindingNames.push(name);\n      }\n      singlePropOffsetValues.push(singlePropIndex);\n    }\n  }\n\n  // just like with the style binding loop above, the new class bindings get the same treatment...\n  const filteredClassBindingNames: string[] = [];\n  if (classBindingNames && classBindingNames.length) {\n    for (let i = 0; i < classBindingNames.length; i++) {\n      const name = classBindingNames[i];\n      let singlePropIndex =\n          getMatchingBindingIndex(context, name, singleClassesStartIndex, multiStylesStartIndex);\n      if (singlePropIndex == -1) {\n        singlePropIndex = multiStylesStartIndex + insertionOffset;\n        insertionOffset += StylingIndex.Size;\n        filteredClassBindingNames.push(name);\n      } else {\n        singlePropIndex += filteredStyleBindingNames.length * StylingIndex.Size;\n      }\n      singlePropOffsetValues.push(singlePropIndex);\n    }\n  }\n\n  // because new styles are being inserted, this means the existing collection of style offset\n  // index values are incorrect (they point to the wrong values). The code below will run through\n  // the entire offset array and update the existing set of index values to point to their new\n  // locations while taking the new binding values into consideration.\n  let i = SinglePropOffsetValuesIndex.ValueStartPosition;\n  if (filteredStyleBindingNames.length) {\n    while (i < currentSinglePropsLength) {\n      const totalStyles =\n          singlePropOffsetValues[i + SinglePropOffsetValuesIndex.StylesCountPosition];\n      const totalClasses =\n          singlePropOffsetValues[i + SinglePropOffsetValuesIndex.ClassesCountPosition];\n      if (totalClasses) {\n        const start = i + SinglePropOffsetValuesIndex.ValueStartPosition + totalStyles;\n        for (let j = start; j < start + totalClasses; j++) {\n          singlePropOffsetValues[j] += filteredStyleBindingNames.length * StylingIndex.Size;\n        }\n      }\n\n      const total = totalStyles + totalClasses;\n      i += SinglePropOffsetValuesIndex.ValueStartPosition + total;\n    }\n  }\n\n  const totalNewEntries = filteredClassBindingNames.length + filteredStyleBindingNames.length;\n\n  // in the event that there are new style values being inserted, all existing class and style\n  // bindings need to have their pointer values offsetted with the new amount of space that is\n  // used for the new style/class bindings.\n  for (let i = singleStylesStartIndex; i < context.length; i += StylingIndex.Size) {\n    const isMultiBased = i >= multiStylesStartIndex;\n    const isClassBased = i >= (isMultiBased ? multiClassesStartIndex : singleClassesStartIndex);\n    const flag = getPointers(context, i);\n    const staticIndex = getInitialIndex(flag);\n    let singleOrMultiIndex = getMultiOrSingleIndex(flag);\n    if (isMultiBased) {\n      singleOrMultiIndex +=\n          isClassBased ? (filteredStyleBindingNames.length * StylingIndex.Size) : 0;\n    } else {\n      singleOrMultiIndex += (totalNewEntries * StylingIndex.Size) +\n          ((isClassBased ? filteredStyleBindingNames.length : 0) * StylingIndex.Size);\n    }\n    setFlag(context, i, pointers(flag, staticIndex, singleOrMultiIndex));\n  }\n\n  // this is where we make space in the context for the new style bindings\n  for (let i = 0; i < filteredStyleBindingNames.length * StylingIndex.Size; i++) {\n    context.splice(multiClassesStartIndex, 0, null);\n    context.splice(singleClassesStartIndex, 0, null);\n    singleClassesStartIndex++;\n    multiStylesStartIndex++;\n    multiClassesStartIndex += 2;  // both single + multi slots were inserted\n  }\n\n  // this is where we make space in the context for the new class bindings\n  for (let i = 0; i < filteredClassBindingNames.length * StylingIndex.Size; i++) {\n    context.splice(multiStylesStartIndex, 0, null);\n    context.push(null);\n    multiStylesStartIndex++;\n    multiClassesStartIndex++;\n  }\n\n  const initialClasses = context[StylingIndex.InitialClassValuesPosition];\n  const initialStyles = context[StylingIndex.InitialStyleValuesPosition];\n\n  // the code below will insert each new entry into the context and assign the appropriate\n  // flags and index values to them. It's important this runs at the end of this function\n  // because the context, property offset and index values have all been computed just before.\n  for (let i = 0; i < totalNewEntries; i++) {\n    const entryIsClassBased = i >= filteredStyleBindingNames.length;\n    const adjustedIndex = entryIsClassBased ? (i - filteredStyleBindingNames.length) : i;\n    const propName = entryIsClassBased ? filteredClassBindingNames[adjustedIndex] :\n                                         filteredStyleBindingNames[adjustedIndex];\n\n    let multiIndex, singleIndex;\n    if (entryIsClassBased) {\n      multiIndex = multiClassesStartIndex +\n          ((totalCurrentClassBindings + adjustedIndex) * StylingIndex.Size);\n      singleIndex = singleClassesStartIndex +\n          ((totalCurrentClassBindings + adjustedIndex) * StylingIndex.Size);\n    } else {\n      multiIndex =\n          multiStylesStartIndex + ((totalCurrentStyleBindings + adjustedIndex) * StylingIndex.Size);\n      singleIndex = singleStylesStartIndex +\n          ((totalCurrentStyleBindings + adjustedIndex) * StylingIndex.Size);\n    }\n\n    // if a property is not found in the initial style values list then it\n    // is ALWAYS added incase a follow-up directive introduces the same initial\n    // style/class value later on.\n    let initialValuesToLookup = entryIsClassBased ? initialClasses : initialStyles;\n    let indexForInitial = getInitialStylingValuesIndexOf(initialValuesToLookup, propName);\n    if (indexForInitial === -1) {\n      indexForInitial = initialValuesToLookup.length + InitialStylingValuesIndex.ValueOffset;\n      initialValuesToLookup.push(propName, entryIsClassBased ? false : null);\n    } else {\n      indexForInitial += InitialStylingValuesIndex.ValueOffset;\n    }\n\n    const initialFlag =\n        prepareInitialFlag(context, propName, entryIsClassBased, styleSanitizer || null);\n\n    setFlag(context, singleIndex, pointers(initialFlag, indexForInitial, multiIndex));\n    setProp(context, singleIndex, propName);\n    setValue(context, singleIndex, null);\n    setPlayerBuilderIndex(context, singleIndex, 0, directiveIndex);\n\n    setFlag(context, multiIndex, pointers(initialFlag, indexForInitial, singleIndex));\n    setProp(context, multiIndex, propName);\n    setValue(context, multiIndex, null);\n    setPlayerBuilderIndex(context, multiIndex, 0, directiveIndex);\n  }\n\n  // the total classes/style values are updated so the next time the context is patched\n  // additional style/class bindings from another directive then it knows exactly where\n  // to insert them in the context\n  singlePropOffsetValues[SinglePropOffsetValuesIndex.ClassesCountPosition] =\n      totalCurrentClassBindings + filteredClassBindingNames.length;\n  singlePropOffsetValues[SinglePropOffsetValuesIndex.StylesCountPosition] =\n      totalCurrentStyleBindings + filteredStyleBindingNames.length;\n\n  // there is no initial value flag for the master index since it doesn't\n  // reference an initial style value\n  const masterFlag = pointers(0, 0, multiStylesStartIndex) |\n      (onlyProcessSingleClasses ? StylingFlags.OnlyProcessSingleClasses : 0);\n  setFlag(context, StylingIndex.MasterFlagPosition, masterFlag);\n}\n\n/**\n * Searches through the existing registry of directives\n */\nfunction findOrPatchDirectiveIntoRegistry(\n    context: StylingContext, directiveRef: any, styleSanitizer?: StyleSanitizeFn | null) {\n  const directiveRefs = context[StylingIndex.DirectiveRegistryPosition];\n  const nextOffsetInsertionIndex = context[StylingIndex.SinglePropOffsetPositions].length;\n\n  let directiveIndex: number;\n  const detectedIndex = getDirectiveRegistryValuesIndexOf(directiveRefs, directiveRef);\n\n  if (detectedIndex === -1) {\n    directiveIndex = directiveRefs.length / DirectiveRegistryValuesIndex.Size;\n    directiveRefs.push(directiveRef, nextOffsetInsertionIndex, false, styleSanitizer || null);\n  } else {\n    const singlePropStartPosition =\n        detectedIndex + DirectiveRegistryValuesIndex.SinglePropValuesIndexOffset;\n    if (directiveRefs[singlePropStartPosition] ! >= 0) {\n      // the directive has already been patched into the context\n      return -1;\n    }\n\n    directiveIndex = detectedIndex / DirectiveRegistryValuesIndex.Size;\n\n    // because the directive already existed this means that it was set during elementHostAttrs or\n    // elementStart which means that the binding values were not here. Therefore, the values below\n    // need to be applied so that single class and style properties can be assigned later.\n    const singlePropPositionIndex =\n        detectedIndex + DirectiveRegistryValuesIndex.SinglePropValuesIndexOffset;\n    directiveRefs[singlePropPositionIndex] = nextOffsetInsertionIndex;\n\n    // the sanitizer is also apart of the binding process and will be used when bindings are\n    // applied.\n    const styleSanitizerIndex = detectedIndex + DirectiveRegistryValuesIndex.StyleSanitizerOffset;\n    directiveRefs[styleSanitizerIndex] = styleSanitizer || null;\n  }\n\n  return directiveIndex;\n}\n\nfunction getMatchingBindingIndex(\n    context: StylingContext, bindingName: string, start: number, end: number) {\n  for (let j = start; j < end; j += StylingIndex.Size) {\n    if (getProp(context, j) === bindingName) return j;\n  }\n  return -1;\n}\n\n/**\n * Sets and resolves all `multi` styling on an `StylingContext` so that they can be\n * applied to the element once `renderStyling` is called.\n *\n * All missing styles/class (any values that are not provided in the new `styles`\n * or `classes` params) will resolve to `null` within their respective positions\n * in the context.\n *\n * @param context The styling context that will be updated with the\n *    newly provided style values.\n * @param classesInput The key/value map of CSS class names that will be used for the update.\n * @param stylesInput The key/value map of CSS styles that will be used for the update.\n */\nexport function updateStylingMap(\n    context: StylingContext, classesInput: {[key: string]: any} | string |\n        BoundPlayerFactory<null|string|{[key: string]: any}>| NO_CHANGE | null,\n    stylesInput?: {[key: string]: any} | BoundPlayerFactory<null|{[key: string]: any}>| NO_CHANGE |\n        null,\n    directiveRef?: any): void {\n  stylesInput = stylesInput || null;\n\n  const directiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);\n  const element = context[StylingIndex.ElementPosition] !as HTMLElement;\n  const classesPlayerBuilder = classesInput instanceof BoundPlayerFactory ?\n      new ClassAndStylePlayerBuilder(classesInput as any, element, BindingType.Class) :\n      null;\n  const stylesPlayerBuilder = stylesInput instanceof BoundPlayerFactory ?\n      new ClassAndStylePlayerBuilder(stylesInput as any, element, BindingType.Style) :\n      null;\n\n  const classesValue = classesPlayerBuilder ?\n      (classesInput as BoundPlayerFactory<{[key: string]: any}|string>) !.value :\n      classesInput;\n  const stylesValue = stylesPlayerBuilder ? stylesInput !.value : stylesInput;\n  // early exit (this is what's done to avoid using ctx.bind() to cache the value)\n  const ignoreAllClassUpdates = limitToSingleClasses(context) || classesValue === NO_CHANGE ||\n      classesValue === context[StylingIndex.CachedClassValueOrInitialClassString];\n  const ignoreAllStyleUpdates =\n      stylesValue === NO_CHANGE || stylesValue === context[StylingIndex.CachedStyleValue];\n  if (ignoreAllClassUpdates && ignoreAllStyleUpdates) return;\n\n  context[StylingIndex.CachedClassValueOrInitialClassString] = classesValue;\n  context[StylingIndex.CachedStyleValue] = stylesValue;\n\n  let classNames: string[] = EMPTY_ARRAY;\n  let applyAllClasses = false;\n  let playerBuildersAreDirty = false;\n\n  const classesPlayerBuilderIndex =\n      classesPlayerBuilder ? PlayerIndex.ClassMapPlayerBuilderPosition : 0;\n  if (hasPlayerBuilderChanged(\n          context, classesPlayerBuilder, PlayerIndex.ClassMapPlayerBuilderPosition)) {\n    setPlayerBuilder(context, classesPlayerBuilder, PlayerIndex.ClassMapPlayerBuilderPosition);\n    playerBuildersAreDirty = true;\n  }\n\n  const stylesPlayerBuilderIndex =\n      stylesPlayerBuilder ? PlayerIndex.StyleMapPlayerBuilderPosition : 0;\n  if (hasPlayerBuilderChanged(\n          context, stylesPlayerBuilder, PlayerIndex.StyleMapPlayerBuilderPosition)) {\n    setPlayerBuilder(context, stylesPlayerBuilder, PlayerIndex.StyleMapPlayerBuilderPosition);\n    playerBuildersAreDirty = true;\n  }\n\n  // each time a string-based value pops up then it shouldn't require a deep\n  // check of what's changed.\n  if (!ignoreAllClassUpdates) {\n    if (typeof classesValue == 'string') {\n      classNames = classesValue.split(/\\s+/);\n      // this boolean is used to avoid having to create a key/value map of `true` values\n      // since a classname string implies that all those classes are added\n      applyAllClasses = true;\n    } else {\n      classNames = classesValue ? Object.keys(classesValue) : EMPTY_ARRAY;\n    }\n  }\n\n  const classes = (classesValue || EMPTY_OBJ) as{[key: string]: any};\n  const styleProps = stylesValue ? Object.keys(stylesValue) : EMPTY_ARRAY;\n  const styles = stylesValue || EMPTY_OBJ;\n\n  const classesStartIndex = styleProps.length;\n  let multiStartIndex = getMultiStartIndex(context);\n\n  let dirty = false;\n  let ctxIndex = multiStartIndex;\n\n  let propIndex = 0;\n  const propLimit = styleProps.length + classNames.length;\n\n  // the main loop here will try and figure out how the shape of the provided\n  // styles differ with respect to the context. Later if the context/styles/classes\n  // are off-balance then they will be dealt in another loop after this one\n  while (ctxIndex < context.length && propIndex < propLimit) {\n    const isClassBased = propIndex >= classesStartIndex;\n    const processValue =\n        (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);\n\n    // when there is a cache-hit for a string-based class then we should\n    // avoid doing any work diffing any of the changes\n    if (processValue) {\n      const adjustedPropIndex = isClassBased ? propIndex - classesStartIndex : propIndex;\n      const newProp: string =\n          isClassBased ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];\n      const newValue: string|boolean =\n          isClassBased ? (applyAllClasses ? true : classes[newProp]) : styles[newProp];\n      const playerBuilderIndex =\n          isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n\n      const prop = getProp(context, ctxIndex);\n      if (prop === newProp) {\n        const value = getValue(context, ctxIndex);\n        const flag = getPointers(context, ctxIndex);\n        setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex, directiveIndex);\n\n        if (hasValueChanged(flag, value, newValue)) {\n          setValue(context, ctxIndex, newValue);\n          playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n\n          const initialValue = getInitialValue(context, flag);\n\n          // SKIP IF INITIAL CHECK\n          // If the former `value` is `null` then it means that an initial value\n          // could be being rendered on screen. If that is the case then there is\n          // no point in updating the value incase it matches. In other words if the\n          // new value is the exact same as the previously rendered value (which\n          // happens to be the initial value) then do nothing.\n          if (value != null || hasValueChanged(flag, initialValue, newValue)) {\n            setDirty(context, ctxIndex, true);\n            dirty = true;\n          }\n        }\n      } else {\n        const indexOfEntry = findEntryPositionByProp(context, newProp, ctxIndex);\n        if (indexOfEntry > 0) {\n          // it was found at a later point ... just swap the values\n          const valueToCompare = getValue(context, indexOfEntry);\n          const flagToCompare = getPointers(context, indexOfEntry);\n          swapMultiContextEntries(context, ctxIndex, indexOfEntry);\n          if (hasValueChanged(flagToCompare, valueToCompare, newValue)) {\n            const initialValue = getInitialValue(context, flagToCompare);\n            setValue(context, ctxIndex, newValue);\n\n            // same if statement logic as above (look for SKIP IF INITIAL CHECK).\n            if (valueToCompare != null || hasValueChanged(flagToCompare, initialValue, newValue)) {\n              setDirty(context, ctxIndex, true);\n              playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n              dirty = true;\n            }\n          }\n        } else {\n          // we only care to do this if the insertion is in the middle\n          const newFlag = prepareInitialFlag(\n              context, newProp, isClassBased, getStyleSanitizer(context, directiveIndex));\n          playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n          insertNewMultiProperty(\n              context, ctxIndex, isClassBased, newProp, newFlag, newValue, directiveIndex,\n              playerBuilderIndex);\n          dirty = true;\n        }\n      }\n    }\n\n    ctxIndex += StylingIndex.Size;\n    propIndex++;\n  }\n\n  // this means that there are left-over values in the context that\n  // were not included in the provided styles/classes and in this\n  // case the  goal is to \"remove\" them from the context (by nullifying)\n  while (ctxIndex < context.length) {\n    const flag = getPointers(context, ctxIndex);\n    const isClassBased = (flag & StylingFlags.Class) === StylingFlags.Class;\n    const processValue =\n        (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);\n    if (processValue) {\n      const value = getValue(context, ctxIndex);\n      const doRemoveValue = valueExists(value, isClassBased);\n      if (doRemoveValue) {\n        setDirty(context, ctxIndex, true);\n        setValue(context, ctxIndex, null);\n\n        // we keep the player factory the same so that the `nulled` value can\n        // be instructed into the player because removing a style and/or a class\n        // is a valid animation player instruction.\n        const playerBuilderIndex =\n            isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n        setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex, directiveIndex);\n        dirty = true;\n      }\n    }\n    ctxIndex += StylingIndex.Size;\n  }\n\n  // this means that there are left-over properties in the context that\n  // were not detected in the context during the loop above. In that\n  // case we want to add the new entries into the list\n  const sanitizer = getStyleSanitizer(context, directiveIndex);\n  while (propIndex < propLimit) {\n    const isClassBased = propIndex >= classesStartIndex;\n    const processValue =\n        (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);\n    if (processValue) {\n      const adjustedPropIndex = isClassBased ? propIndex - classesStartIndex : propIndex;\n      const prop = isClassBased ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];\n      const value: string|boolean =\n          isClassBased ? (applyAllClasses ? true : classes[prop]) : styles[prop];\n      const flag = prepareInitialFlag(context, prop, isClassBased, sanitizer) | StylingFlags.Dirty;\n      const playerBuilderIndex =\n          isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n      const ctxIndex = context.length;\n      context.push(flag, prop, value, 0);\n      setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex, directiveIndex);\n      dirty = true;\n    }\n    propIndex++;\n  }\n\n  if (dirty) {\n    setContextDirty(context, true);\n    setDirectiveDirty(context, directiveIndex, true);\n  }\n\n  if (playerBuildersAreDirty) {\n    setContextPlayersDirty(context, true);\n  }\n}\n\n/**\n * This method will toggle the referenced CSS class (by the provided index)\n * within the given context.\n *\n * @param context The styling context that will be updated with the\n *    newly provided class value.\n * @param offset The index of the CSS class which is being updated.\n * @param addOrRemove Whether or not to add or remove the CSS class\n */\nexport function updateClassProp(\n    context: StylingContext, offset: number, addOrRemove: boolean | BoundPlayerFactory<boolean>,\n    directiveRef?: any): void {\n  _updateSingleStylingValue(context, offset, addOrRemove, true, directiveRef);\n}\n\n/**\n * Sets and resolves a single style value on the provided `StylingContext` so\n * that they can be applied to the element once `renderStyling` is called.\n *\n * Note that prop-level styling values are considered higher priority than any styling that\n * has been applied using `updateStylingMap`, therefore, when styling values are rendered\n * then any styles/classes that have been applied using this function will be considered first\n * (then multi values second and then initial values as a backup).\n *\n * @param context The styling context that will be updated with the\n *    newly provided style value.\n * @param offset The index of the property which is being updated.\n * @param value The CSS style value that will be assigned\n * @param directiveRef an optional reference to the directive responsible\n *    for this binding change. If present then style binding will only\n *    actualize if the directive has ownership over this binding\n *    (see styling.ts#directives for more information about the algorithm).\n */\nexport function updateStyleProp(\n    context: StylingContext, offset: number,\n    input: string | boolean | null | BoundPlayerFactory<string|boolean|null>,\n    directiveRef?: any): void {\n  _updateSingleStylingValue(context, offset, input, false, directiveRef);\n}\n\nfunction _updateSingleStylingValue(\n    context: StylingContext, offset: number,\n    input: string | boolean | null | BoundPlayerFactory<string|boolean|null>, isClassBased: boolean,\n    directiveRef: any): void {\n  const directiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);\n  const singleIndex = getSinglePropIndexValue(context, directiveIndex, offset, isClassBased);\n  const currValue = getValue(context, singleIndex);\n  const currFlag = getPointers(context, singleIndex);\n  const currDirective = getDirectiveIndexFromEntry(context, singleIndex);\n  const value: string|boolean|null = (input instanceof BoundPlayerFactory) ? input.value : input;\n\n  if (hasValueChanged(currFlag, currValue, value) &&\n      allowValueChange(currValue, value, currDirective, directiveIndex)) {\n    const isClassBased = (currFlag & StylingFlags.Class) === StylingFlags.Class;\n    const element = context[StylingIndex.ElementPosition] !as HTMLElement;\n    const playerBuilder = input instanceof BoundPlayerFactory ?\n        new ClassAndStylePlayerBuilder(\n            input as any, element, isClassBased ? BindingType.Class : BindingType.Style) :\n        null;\n    const value = (playerBuilder ? (input as BoundPlayerFactory<any>).value : input) as string |\n        boolean | null;\n    const currPlayerIndex = getPlayerBuilderIndex(context, singleIndex);\n\n    let playerBuildersAreDirty = false;\n    let playerBuilderIndex = playerBuilder ? currPlayerIndex : 0;\n    if (hasPlayerBuilderChanged(context, playerBuilder, currPlayerIndex)) {\n      const newIndex = setPlayerBuilder(context, playerBuilder, currPlayerIndex);\n      playerBuilderIndex = playerBuilder ? newIndex : 0;\n      playerBuildersAreDirty = true;\n    }\n\n    if (playerBuildersAreDirty || currDirective !== directiveIndex) {\n      setPlayerBuilderIndex(context, singleIndex, playerBuilderIndex, directiveIndex);\n    }\n\n    if (currDirective !== directiveIndex) {\n      const prop = getProp(context, singleIndex);\n      const sanitizer = getStyleSanitizer(context, directiveIndex);\n      setSanitizeFlag(context, singleIndex, (sanitizer && sanitizer(prop)) ? true : false);\n    }\n\n    // the value will always get updated (even if the dirty flag is skipped)\n    setValue(context, singleIndex, value);\n    const indexForMulti = getMultiOrSingleIndex(currFlag);\n\n    // if the value is the same in the multi-area then there's no point in re-assembling\n    const valueForMulti = getValue(context, indexForMulti);\n    if (!valueForMulti || hasValueChanged(currFlag, valueForMulti, value)) {\n      let multiDirty = false;\n      let singleDirty = true;\n\n      // only when the value is set to `null` should the multi-value get flagged\n      if (!valueExists(value, isClassBased) && valueExists(valueForMulti, isClassBased)) {\n        multiDirty = true;\n        singleDirty = false;\n      }\n\n      setDirty(context, indexForMulti, multiDirty);\n      setDirty(context, singleIndex, singleDirty);\n      setDirectiveDirty(context, directiveIndex, true);\n      setContextDirty(context, true);\n    }\n\n    if (playerBuildersAreDirty) {\n      setContextPlayersDirty(context, true);\n    }\n  }\n}\n\n\n/**\n * Renders all queued styling using a renderer onto the given element.\n *\n * This function works by rendering any styles (that have been applied\n * using `updateStylingMap`) and any classes (that have been applied using\n * `updateStyleProp`) onto the provided element using the provided renderer.\n * Just before the styles/classes are rendered a final key/value style map\n * will be assembled (if `styleStore` or `classStore` are provided).\n *\n * @param lElement the element that the styles will be rendered on\n * @param context The styling context that will be used to determine\n *      what styles will be rendered\n * @param renderer the renderer that will be used to apply the styling\n * @param classesStore if provided, the updated class values will be applied\n *    to this key/value map instead of being renderered via the renderer.\n * @param stylesStore if provided, the updated style values will be applied\n *    to this key/value map instead of being renderered via the renderer.\n * @param directiveRef an optional directive that will be used to target which\n *    styling values are rendered. If left empty, only the bindings that are\n *    registered on the template will be rendered.\n * @returns number the total amount of players that got queued for animation (if any)\n */\nexport function renderStyling(\n    context: StylingContext, renderer: Renderer3, rootOrView: RootContext | LView,\n    isFirstRender: boolean, classesStore?: BindingStore | null, stylesStore?: BindingStore | null,\n    directiveRef?: any): number {\n  let totalPlayersQueued = 0;\n  const targetDirectiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);\n\n  if (isContextDirty(context) && isDirectiveDirty(context, targetDirectiveIndex)) {\n    const flushPlayerBuilders: any =\n        context[StylingIndex.MasterFlagPosition] & StylingFlags.PlayerBuildersDirty;\n    const native = context[StylingIndex.ElementPosition] !;\n    const multiStartIndex = getMultiStartIndex(context);\n    const onlySingleClasses = limitToSingleClasses(context);\n\n    let stillDirty = false;\n    for (let i = StylingIndex.SingleStylesStartPosition; i < context.length;\n         i += StylingIndex.Size) {\n      // there is no point in rendering styles that have not changed on screen\n      if (isDirty(context, i)) {\n        const flag = getPointers(context, i);\n        const directiveIndex = getDirectiveIndexFromEntry(context, i);\n        if (targetDirectiveIndex !== directiveIndex) {\n          stillDirty = true;\n          continue;\n        }\n\n        const prop = getProp(context, i);\n        const value = getValue(context, i);\n        const styleSanitizer =\n            (flag & StylingFlags.Sanitize) ? getStyleSanitizer(context, directiveIndex) : null;\n        const playerBuilder = getPlayerBuilder(context, i);\n        const isClassBased = flag & StylingFlags.Class ? true : false;\n        const isInSingleRegion = i < multiStartIndex;\n        const readInitialValue = !isClassBased || !onlySingleClasses;\n\n        let valueToApply: string|boolean|null = value;\n\n        // VALUE DEFER CASE 1: Use a multi value instead of a null single value\n        // this check implies that a single value was removed and we\n        // should now defer to a multi value and use that (if set).\n        if (isInSingleRegion && !valueExists(valueToApply, isClassBased)) {\n          // single values ALWAYS have a reference to a multi index\n          const multiIndex = getMultiOrSingleIndex(flag);\n          valueToApply = getValue(context, multiIndex);\n        }\n\n        // VALUE DEFER CASE 2: Use the initial value if all else fails (is falsy)\n        // the initial value will always be a string or null,\n        // therefore we can safely adopt it incase there's nothing else\n        // note that this should always be a falsy check since `false` is used\n        // for both class and style comparisons (styles can't be false and false\n        // classes are turned off and should therefore defer to their initial values)\n        // Note that we ignore class-based deferals because otherwise a class can never\n        // be removed in the case that it exists as true in the initial classes list...\n        if (!isClassBased && !valueExists(valueToApply, isClassBased) && readInitialValue) {\n          valueToApply = getInitialValue(context, flag);\n        }\n\n        // if the first render is true then we do not want to start applying falsy\n        // values to the DOM element's styling. Otherwise then we know there has\n        // been a change and even if it's falsy then it's removing something that\n        // was truthy before.\n        const doApplyValue = isFirstRender ? valueToApply : true;\n        if (doApplyValue) {\n          if (isClassBased) {\n            setClass(\n                native, prop, valueToApply ? true : false, renderer, classesStore, playerBuilder);\n          } else {\n            setStyle(\n                native, prop, valueToApply as string | null, renderer, styleSanitizer, stylesStore,\n                playerBuilder);\n          }\n        }\n\n        setDirty(context, i, false);\n      }\n    }\n\n    if (flushPlayerBuilders) {\n      const rootContext =\n          Array.isArray(rootOrView) ? getRootContext(rootOrView) : rootOrView as RootContext;\n      const playerContext = getPlayerContext(context) !;\n      const playersStartIndex = playerContext[PlayerIndex.NonBuilderPlayersStart];\n      for (let i = PlayerIndex.PlayerBuildersStartPosition; i < playersStartIndex;\n           i += PlayerIndex.PlayerAndPlayerBuildersTupleSize) {\n        const builder = playerContext[i] as ClassAndStylePlayerBuilder<any>| null;\n        const playerInsertionIndex = i + PlayerIndex.PlayerOffsetPosition;\n        const oldPlayer = playerContext[playerInsertionIndex] as Player | null;\n        if (builder) {\n          const player = builder.buildPlayer(oldPlayer, isFirstRender);\n          if (player !== undefined) {\n            if (player != null) {\n              const wasQueued = addPlayerInternal(\n                  playerContext, rootContext, native as HTMLElement, player, playerInsertionIndex);\n              wasQueued && totalPlayersQueued++;\n            }\n            if (oldPlayer) {\n              oldPlayer.destroy();\n            }\n          }\n        } else if (oldPlayer) {\n          // the player builder has been removed ... therefore we should delete the associated\n          // player\n          oldPlayer.destroy();\n        }\n      }\n      setContextPlayersDirty(context, false);\n    }\n\n    setDirectiveDirty(context, targetDirectiveIndex, false);\n    setContextDirty(context, stillDirty);\n  }\n\n  return totalPlayersQueued;\n}\n\n/**\n * This function renders a given CSS prop/value entry using the\n * provided renderer. If a `store` value is provided then\n * that will be used a render context instead of the provided\n * renderer.\n *\n * @param native the DOM Element\n * @param prop the CSS style property that will be rendered\n * @param value the CSS style value that will be rendered\n * @param renderer\n * @param store an optional key/value map that will be used as a context to render styles on\n */\nexport function setStyle(\n    native: any, prop: string, value: string | null, renderer: Renderer3,\n    sanitizer: StyleSanitizeFn | null, store?: BindingStore | null,\n    playerBuilder?: ClassAndStylePlayerBuilder<any>| null) {\n  value = sanitizer && value ? sanitizer(prop, value) : value;\n  if (store || playerBuilder) {\n    if (store) {\n      store.setValue(prop, value);\n    }\n    if (playerBuilder) {\n      playerBuilder.setValue(prop, value);\n    }\n  } else if (value) {\n    value = value.toString();  // opacity, z-index and flexbox all have number values which may not\n                               // assign as numbers\n    ngDevMode && ngDevMode.rendererSetStyle++;\n    isProceduralRenderer(renderer) ?\n        renderer.setStyle(native, prop, value, RendererStyleFlags3.DashCase) :\n        native['style'].setProperty(prop, value);\n  } else {\n    ngDevMode && ngDevMode.rendererRemoveStyle++;\n    isProceduralRenderer(renderer) ?\n        renderer.removeStyle(native, prop, RendererStyleFlags3.DashCase) :\n        native['style'].removeProperty(prop);\n  }\n}\n\n/**\n * This function renders a given CSS class value using the provided\n * renderer (by adding or removing it from the provided element).\n * If a `store` value is provided then that will be used a render\n * context instead of the provided renderer.\n *\n * @param native the DOM Element\n * @param prop the CSS style property that will be rendered\n * @param value the CSS style value that will be rendered\n * @param renderer\n * @param store an optional key/value map that will be used as a context to render styles on\n */\nfunction setClass(\n    native: any, className: string, add: boolean, renderer: Renderer3, store?: BindingStore | null,\n    playerBuilder?: ClassAndStylePlayerBuilder<any>| null) {\n  if (store || playerBuilder) {\n    if (store) {\n      store.setValue(className, add);\n    }\n    if (playerBuilder) {\n      playerBuilder.setValue(className, add);\n    }\n  } else if (add) {\n    ngDevMode && ngDevMode.rendererAddClass++;\n    isProceduralRenderer(renderer) ? renderer.addClass(native, className) :\n                                     native['classList'].add(className);\n  } else {\n    ngDevMode && ngDevMode.rendererRemoveClass++;\n    isProceduralRenderer(renderer) ? renderer.removeClass(native, className) :\n                                     native['classList'].remove(className);\n  }\n}\n\nfunction setSanitizeFlag(context: StylingContext, index: number, sanitizeYes: boolean) {\n  if (sanitizeYes) {\n    (context[index] as number) |= StylingFlags.Sanitize;\n  } else {\n    (context[index] as number) &= ~StylingFlags.Sanitize;\n  }\n}\n\nfunction setDirty(context: StylingContext, index: number, isDirtyYes: boolean) {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  if (isDirtyYes) {\n    (context[adjustedIndex] as number) |= StylingFlags.Dirty;\n  } else {\n    (context[adjustedIndex] as number) &= ~StylingFlags.Dirty;\n  }\n}\n\nfunction isDirty(context: StylingContext, index: number): boolean {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  return ((context[adjustedIndex] as number) & StylingFlags.Dirty) == StylingFlags.Dirty;\n}\n\nexport function isClassBasedValue(context: StylingContext, index: number): boolean {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  return ((context[adjustedIndex] as number) & StylingFlags.Class) == StylingFlags.Class;\n}\n\nfunction isSanitizable(context: StylingContext, index: number): boolean {\n  const adjustedIndex =\n      index >= StylingIndex.SingleStylesStartPosition ? (index + StylingIndex.FlagsOffset) : index;\n  return ((context[adjustedIndex] as number) & StylingFlags.Sanitize) == StylingFlags.Sanitize;\n}\n\nfunction pointers(configFlag: number, staticIndex: number, dynamicIndex: number) {\n  return (configFlag & StylingFlags.BitMask) | (staticIndex << StylingFlags.BitCountSize) |\n      (dynamicIndex << (StylingIndex.BitCountSize + StylingFlags.BitCountSize));\n}\n\nfunction getInitialValue(context: StylingContext, flag: number): string|boolean|null {\n  const index = getInitialIndex(flag);\n  const entryIsClassBased = flag & StylingFlags.Class;\n  const initialValues = entryIsClassBased ? context[StylingIndex.InitialClassValuesPosition] :\n                                            context[StylingIndex.InitialStyleValuesPosition];\n  return initialValues[index];\n}\n\nfunction getInitialIndex(flag: number): number {\n  return (flag >> StylingFlags.BitCountSize) & StylingIndex.BitMask;\n}\n\nfunction getMultiOrSingleIndex(flag: number): number {\n  const index =\n      (flag >> (StylingIndex.BitCountSize + StylingFlags.BitCountSize)) & StylingIndex.BitMask;\n  return index >= StylingIndex.SingleStylesStartPosition ? index : -1;\n}\n\nfunction getMultiStartIndex(context: StylingContext): number {\n  return getMultiOrSingleIndex(context[StylingIndex.MasterFlagPosition]) as number;\n}\n\nfunction setProp(context: StylingContext, index: number, prop: string) {\n  context[index + StylingIndex.PropertyOffset] = prop;\n}\n\nfunction setValue(context: StylingContext, index: number, value: string | null | boolean) {\n  context[index + StylingIndex.ValueOffset] = value;\n}\n\nfunction hasPlayerBuilderChanged(\n    context: StylingContext, builder: ClassAndStylePlayerBuilder<any>| null, index: number) {\n  const playerContext = context[StylingIndex.PlayerContext] !;\n  if (builder) {\n    if (!playerContext || index === 0) {\n      return true;\n    }\n  } else if (!playerContext) {\n    return false;\n  }\n  return playerContext[index] !== builder;\n}\n\nfunction setPlayerBuilder(\n    context: StylingContext, builder: ClassAndStylePlayerBuilder<any>| null,\n    insertionIndex: number): number {\n  let playerContext = context[StylingIndex.PlayerContext] || allocPlayerContext(context);\n  if (insertionIndex > 0) {\n    playerContext[insertionIndex] = builder;\n  } else {\n    insertionIndex = playerContext[PlayerIndex.NonBuilderPlayersStart];\n    playerContext.splice(insertionIndex, 0, builder, null);\n    playerContext[PlayerIndex.NonBuilderPlayersStart] +=\n        PlayerIndex.PlayerAndPlayerBuildersTupleSize;\n  }\n  return insertionIndex;\n}\n\nexport function directiveOwnerPointers(directiveIndex: number, playerIndex: number) {\n  return (playerIndex << DirectiveOwnerAndPlayerBuilderIndex.BitCountSize) | directiveIndex;\n}\n\nfunction setPlayerBuilderIndex(\n    context: StylingContext, index: number, playerBuilderIndex: number, directiveIndex: number) {\n  const value = directiveOwnerPointers(directiveIndex, playerBuilderIndex);\n  context[index + StylingIndex.PlayerBuilderIndexOffset] = value;\n}\n\nfunction getPlayerBuilderIndex(context: StylingContext, index: number): number {\n  const flag = context[index + StylingIndex.PlayerBuilderIndexOffset] as number;\n  const playerBuilderIndex = (flag >> DirectiveOwnerAndPlayerBuilderIndex.BitCountSize) &\n      DirectiveOwnerAndPlayerBuilderIndex.BitMask;\n  return playerBuilderIndex;\n}\n\nfunction getPlayerBuilder(context: StylingContext, index: number): ClassAndStylePlayerBuilder<any>|\n    null {\n  const playerBuilderIndex = getPlayerBuilderIndex(context, index);\n  if (playerBuilderIndex) {\n    const playerContext = context[StylingIndex.PlayerContext];\n    if (playerContext) {\n      return playerContext[playerBuilderIndex] as ClassAndStylePlayerBuilder<any>| null;\n    }\n  }\n  return null;\n}\n\nfunction setFlag(context: StylingContext, index: number, flag: number) {\n  const adjustedIndex =\n      index === StylingIndex.MasterFlagPosition ? index : (index + StylingIndex.FlagsOffset);\n  context[adjustedIndex] = flag;\n}\n\nfunction getPointers(context: StylingContext, index: number): number {\n  const adjustedIndex =\n      index === StylingIndex.MasterFlagPosition ? index : (index + StylingIndex.FlagsOffset);\n  return context[adjustedIndex] as number;\n}\n\nexport function getValue(context: StylingContext, index: number): string|boolean|null {\n  return context[index + StylingIndex.ValueOffset] as string | boolean | null;\n}\n\nexport function getProp(context: StylingContext, index: number): string {\n  return context[index + StylingIndex.PropertyOffset] as string;\n}\n\nexport function isContextDirty(context: StylingContext): boolean {\n  return isDirty(context, StylingIndex.MasterFlagPosition);\n}\n\nexport function limitToSingleClasses(context: StylingContext) {\n  return context[StylingIndex.MasterFlagPosition] & StylingFlags.OnlyProcessSingleClasses;\n}\n\nexport function setContextDirty(context: StylingContext, isDirtyYes: boolean): void {\n  setDirty(context, StylingIndex.MasterFlagPosition, isDirtyYes);\n}\n\nexport function setContextPlayersDirty(context: StylingContext, isDirtyYes: boolean): void {\n  if (isDirtyYes) {\n    (context[StylingIndex.MasterFlagPosition] as number) |= StylingFlags.PlayerBuildersDirty;\n  } else {\n    (context[StylingIndex.MasterFlagPosition] as number) &= ~StylingFlags.PlayerBuildersDirty;\n  }\n}\n\nfunction findEntryPositionByProp(\n    context: StylingContext, prop: string, startIndex?: number): number {\n  for (let i = (startIndex || 0) + StylingIndex.PropertyOffset; i < context.length;\n       i += StylingIndex.Size) {\n    const thisProp = context[i];\n    if (thisProp == prop) {\n      return i - StylingIndex.PropertyOffset;\n    }\n  }\n  return -1;\n}\n\nfunction swapMultiContextEntries(context: StylingContext, indexA: number, indexB: number) {\n  const tmpValue = getValue(context, indexA);\n  const tmpProp = getProp(context, indexA);\n  const tmpFlag = getPointers(context, indexA);\n  const tmpPlayerBuilderIndex = getPlayerBuilderIndex(context, indexA);\n\n  let flagA = tmpFlag;\n  let flagB = getPointers(context, indexB);\n\n  const singleIndexA = getMultiOrSingleIndex(flagA);\n  if (singleIndexA >= 0) {\n    const _flag = getPointers(context, singleIndexA);\n    const _initial = getInitialIndex(_flag);\n    setFlag(context, singleIndexA, pointers(_flag, _initial, indexB));\n  }\n\n  const singleIndexB = getMultiOrSingleIndex(flagB);\n  if (singleIndexB >= 0) {\n    const _flag = getPointers(context, singleIndexB);\n    const _initial = getInitialIndex(_flag);\n    setFlag(context, singleIndexB, pointers(_flag, _initial, indexA));\n  }\n\n  setValue(context, indexA, getValue(context, indexB));\n  setProp(context, indexA, getProp(context, indexB));\n  setFlag(context, indexA, getPointers(context, indexB));\n  const playerIndexA = getPlayerBuilderIndex(context, indexB);\n  const directiveIndexA = 0;\n  setPlayerBuilderIndex(context, indexA, playerIndexA, directiveIndexA);\n\n  setValue(context, indexB, tmpValue);\n  setProp(context, indexB, tmpProp);\n  setFlag(context, indexB, tmpFlag);\n  setPlayerBuilderIndex(context, indexB, tmpPlayerBuilderIndex, directiveIndexA);\n}\n\nfunction updateSinglePointerValues(context: StylingContext, indexStartPosition: number) {\n  for (let i = indexStartPosition; i < context.length; i += StylingIndex.Size) {\n    const multiFlag = getPointers(context, i);\n    const singleIndex = getMultiOrSingleIndex(multiFlag);\n    if (singleIndex > 0) {\n      const singleFlag = getPointers(context, singleIndex);\n      const initialIndexForSingle = getInitialIndex(singleFlag);\n      const flagValue = (isDirty(context, singleIndex) ? StylingFlags.Dirty : StylingFlags.None) |\n          (isClassBasedValue(context, singleIndex) ? StylingFlags.Class : StylingFlags.None) |\n          (isSanitizable(context, singleIndex) ? StylingFlags.Sanitize : StylingFlags.None);\n      const updatedFlag = pointers(flagValue, initialIndexForSingle, i);\n      setFlag(context, singleIndex, updatedFlag);\n    }\n  }\n}\n\nfunction insertNewMultiProperty(\n    context: StylingContext, index: number, classBased: boolean, name: string, flag: number,\n    value: string | boolean, directiveIndex: number, playerIndex: number): void {\n  const doShift = index < context.length;\n\n  // prop does not exist in the list, add it in\n  context.splice(\n      index, 0, flag | StylingFlags.Dirty | (classBased ? StylingFlags.Class : StylingFlags.None),\n      name, value, 0);\n  setPlayerBuilderIndex(context, index, playerIndex, directiveIndex);\n\n  if (doShift) {\n    // because the value was inserted midway into the array then we\n    // need to update all the shifted multi values' single value\n    // pointers to point to the newly shifted location\n    updateSinglePointerValues(context, index + StylingIndex.Size);\n  }\n}\n\nfunction valueExists(value: string | null | boolean, isClassBased?: boolean) {\n  if (isClassBased) {\n    return value ? true : false;\n  }\n  return value !== null;\n}\n\nfunction prepareInitialFlag(\n    context: StylingContext, prop: string, entryIsClassBased: boolean,\n    sanitizer?: StyleSanitizeFn | null) {\n  let flag = (sanitizer && sanitizer(prop)) ? StylingFlags.Sanitize : StylingFlags.None;\n\n  let initialIndex: number;\n  if (entryIsClassBased) {\n    flag |= StylingFlags.Class;\n    initialIndex =\n        getInitialStylingValuesIndexOf(context[StylingIndex.InitialClassValuesPosition], prop);\n  } else {\n    initialIndex =\n        getInitialStylingValuesIndexOf(context[StylingIndex.InitialStyleValuesPosition], prop);\n  }\n\n  initialIndex = initialIndex > 0 ? (initialIndex + InitialStylingValuesIndex.ValueOffset) : 0;\n  return pointers(flag, initialIndex, 0);\n}\n\nfunction hasValueChanged(\n    flag: number, a: string | boolean | null, b: string | boolean | null): boolean {\n  const isClassBased = flag & StylingFlags.Class;\n  const hasValues = a && b;\n  const usesSanitizer = flag & StylingFlags.Sanitize;\n  // the toString() comparison ensures that a value is checked\n  // ... otherwise (during sanitization bypassing) the === comparsion\n  // would fail since a new String() instance is created\n  if (!isClassBased && hasValues && usesSanitizer) {\n    // we know for sure we're dealing with strings at this point\n    return (a as string).toString() !== (b as string).toString();\n  }\n\n  // everything else is safe to check with a normal equality check\n  return a !== b;\n}\n\nexport class ClassAndStylePlayerBuilder<T> implements PlayerBuilder {\n  private _values: {[key: string]: string | null} = {};\n  private _dirty = false;\n  private _factory: BoundPlayerFactory<T>;\n\n  constructor(factory: PlayerFactory, private _element: HTMLElement, private _type: BindingType) {\n    this._factory = factory as any;\n  }\n\n  setValue(prop: string, value: any) {\n    if (this._values[prop] !== value) {\n      this._values[prop] = value;\n      this._dirty = true;\n    }\n  }\n\n  buildPlayer(currentPlayer: Player|null, isFirstRender: boolean): Player|undefined|null {\n    // if no values have been set here then this means the binding didn't\n    // change and therefore the binding values were not updated through\n    // `setValue` which means no new player will be provided.\n    if (this._dirty) {\n      const player = this._factory.fn(\n          this._element, this._type, this._values !, isFirstRender, currentPlayer || null);\n      this._values = {};\n      this._dirty = false;\n      return player;\n    }\n\n    return undefined;\n  }\n}\n\n/**\n * Used to provide a summary of the state of the styling context.\n *\n * This is an internal interface that is only used inside of test tooling to\n * help summarize what's going on within the styling context. None of this code\n * is designed to be exported publicly and will, therefore, be tree-shaken away\n * during runtime.\n */\nexport interface LogSummary {\n  name: string;          //\n  staticIndex: number;   //\n  dynamicIndex: number;  //\n  value: number;         //\n  flags: {\n    dirty: boolean;                     //\n    class: boolean;                     //\n    sanitize: boolean;                  //\n    playerBuildersDirty: boolean;       //\n    onlyProcessSingleClasses: boolean;  //\n    bindingAllocationLocked: boolean;   //\n  };\n}\n\n/**\n * This function is not designed to be used in production.\n * It is a utility tool for debugging and testing and it\n * will automatically be tree-shaken away during production.\n */\nexport function generateConfigSummary(source: number): LogSummary;\nexport function generateConfigSummary(source: StylingContext): LogSummary;\nexport function generateConfigSummary(source: StylingContext, index: number): LogSummary;\nexport function generateConfigSummary(source: number | StylingContext, index?: number): LogSummary {\n  let flag, name = 'config value for ';\n  if (Array.isArray(source)) {\n    if (index) {\n      name += 'index: ' + index;\n    } else {\n      name += 'master config';\n    }\n    index = index || StylingIndex.MasterFlagPosition;\n    flag = source[index] as number;\n  } else {\n    flag = source;\n    name += 'index: ' + flag;\n  }\n  const dynamicIndex = getMultiOrSingleIndex(flag);\n  const staticIndex = getInitialIndex(flag);\n  return {\n    name,\n    staticIndex,\n    dynamicIndex,\n    value: flag,\n    flags: {\n      dirty: flag & StylingFlags.Dirty ? true : false,\n      class: flag & StylingFlags.Class ? true : false,\n      sanitize: flag & StylingFlags.Sanitize ? true : false,\n      playerBuildersDirty: flag & StylingFlags.PlayerBuildersDirty ? true : false,\n      onlyProcessSingleClasses: flag & StylingFlags.OnlyProcessSingleClasses ? true : false,\n      bindingAllocationLocked: flag & StylingFlags.BindingAllocationLocked ? true : false,\n    }\n  };\n}\n\nexport function getDirectiveIndexFromEntry(context: StylingContext, index: number) {\n  const value = context[index + StylingIndex.PlayerBuilderIndexOffset] as number;\n  return value & DirectiveOwnerAndPlayerBuilderIndex.BitMask;\n}\n\nfunction getDirectiveIndexFromRegistry(context: StylingContext, directive: any) {\n  const index =\n      getDirectiveRegistryValuesIndexOf(context[StylingIndex.DirectiveRegistryPosition], directive);\n  ngDevMode &&\n      assertNotEqual(\n          index, -1,\n          `The provided directive ${directive} has not been allocated to the element\\'s style/class bindings`);\n  return index > 0 ? index / DirectiveRegistryValuesIndex.Size : 0;\n  // return index / DirectiveRegistryValuesIndex.Size;\n}\n\nfunction getDirectiveRegistryValuesIndexOf(\n    directives: DirectiveRegistryValues, directive: {}): number {\n  for (let i = 0; i < directives.length; i += DirectiveRegistryValuesIndex.Size) {\n    if (directives[i] === directive) {\n      return i;\n    }\n  }\n  return -1;\n}\n\nfunction getInitialStylingValuesIndexOf(keyValues: InitialStylingValues, key: string): number {\n  for (let i = InitialStylingValuesIndex.KeyValueStartPosition; i < keyValues.length;\n       i += InitialStylingValuesIndex.Size) {\n    if (keyValues[i] === key) return i;\n  }\n  return -1;\n}\n\nexport function compareLogSummaries(a: LogSummary, b: LogSummary) {\n  const log: string[] = [];\n  const diffs: [string, any, any][] = [];\n  diffSummaryValues(diffs, 'staticIndex', 'staticIndex', a, b);\n  diffSummaryValues(diffs, 'dynamicIndex', 'dynamicIndex', a, b);\n  Object.keys(a.flags).forEach(\n      name => { diffSummaryValues(diffs, 'flags.' + name, name, a.flags, b.flags); });\n\n  if (diffs.length) {\n    log.push('Log Summaries for:');\n    log.push('  A: ' + a.name);\n    log.push('  B: ' + b.name);\n    log.push('\\n  Differ in the following way (A !== B):');\n    diffs.forEach(result => {\n      const [name, aVal, bVal] = result;\n      log.push('    => ' + name);\n      log.push('    => ' + aVal + ' !== ' + bVal + '\\n');\n    });\n  }\n\n  return log;\n}\n\nfunction diffSummaryValues(result: any[], name: string, prop: string, a: any, b: any) {\n  const aVal = a[prop];\n  const bVal = b[prop];\n  if (aVal !== bVal) {\n    result.push([name, aVal, bVal]);\n  }\n}\n\nfunction getSinglePropIndexValue(\n    context: StylingContext, directiveIndex: number, offset: number, isClassBased: boolean) {\n  const singlePropOffsetRegistryIndex =\n      context[StylingIndex.DirectiveRegistryPosition]\n             [(directiveIndex * DirectiveRegistryValuesIndex.Size) +\n              DirectiveRegistryValuesIndex.SinglePropValuesIndexOffset] as number;\n  const offsets = context[StylingIndex.SinglePropOffsetPositions];\n  const indexForOffset = singlePropOffsetRegistryIndex +\n      SinglePropOffsetValuesIndex.ValueStartPosition +\n      (isClassBased ?\n           offsets\n               [singlePropOffsetRegistryIndex + SinglePropOffsetValuesIndex.StylesCountPosition] :\n           0) +\n      offset;\n  return offsets[indexForOffset];\n}\n\nfunction getStyleSanitizer(context: StylingContext, directiveIndex: number): StyleSanitizeFn|null {\n  const dirs = context[StylingIndex.DirectiveRegistryPosition];\n  const value = dirs\n                    [directiveIndex * DirectiveRegistryValuesIndex.Size +\n                     DirectiveRegistryValuesIndex.StyleSanitizerOffset] ||\n      dirs[DirectiveRegistryValuesIndex.StyleSanitizerOffset] || null;\n  return value as StyleSanitizeFn | null;\n}\n\nfunction isDirectiveDirty(context: StylingContext, directiveIndex: number): boolean {\n  const dirs = context[StylingIndex.DirectiveRegistryPosition];\n  return dirs\n      [directiveIndex * DirectiveRegistryValuesIndex.Size +\n       DirectiveRegistryValuesIndex.DirtyFlagOffset] as boolean;\n}\n\nfunction setDirectiveDirty(\n    context: StylingContext, directiveIndex: number, dirtyYes: boolean): void {\n  const dirs = context[StylingIndex.DirectiveRegistryPosition];\n  dirs\n      [directiveIndex * DirectiveRegistryValuesIndex.Size +\n       DirectiveRegistryValuesIndex.DirtyFlagOffset] = dirtyYes;\n}\n\nfunction allowValueChange(\n    currentValue: string | boolean | null, newValue: string | boolean | null,\n    currentDirectiveOwner: number, newDirectiveOwner: number) {\n  // the code below relies the importance of directive's being tied to their\n  // index value. The index values for each directive are derived from being\n  // registered into the styling context directive registry. The most important\n  // directive is the parent component directive (the template) and each directive\n  // that is added after is considered less important than the previous entry. This\n  // prioritization of directives enables the styling algorithm to decide if a style\n  // or class should be allowed to be updated/replaced incase an earlier directive\n  // already wrote to the exact same style-property or className value. In other words\n  // ... this decides what to do if and when there is a collision.\n  if (currentValue) {\n    if (newValue) {\n      // if a directive index is lower than it always has priority over the\n      // previous directive's value...\n      return newDirectiveOwner <= currentDirectiveOwner;\n    } else {\n      // only write a null value incase it's the same owner writing it.\n      // this avoids having a higher-priority directive write to null\n      // only to have a lesser-priority directive change right to a\n      // non-null value immediately afterwards.\n      return currentDirectiveOwner === newDirectiveOwner;\n    }\n  }\n  return true;\n}\n\n/**\n * This function is only designed to be called for `[class]` bindings when\n * `[ngClass]` (or something that uses `class` as an input) is present. Once\n * directive host bindings fully work for `[class]` and `[style]` inputs\n * then this can be deleted.\n */\nexport function getInitialClassNameValue(context: StylingContext): string {\n  let className = context[StylingIndex.CachedClassValueOrInitialClassString] as string;\n  if (className == null) {\n    className = '';\n    const initialClassValues = context[StylingIndex.InitialClassValuesPosition];\n    for (let i = InitialStylingValuesIndex.KeyValueStartPosition; i < initialClassValues.length;\n         i += InitialStylingValuesIndex.Size) {\n      const isPresent = initialClassValues[i + 1];\n      if (isPresent) {\n        className += (className.length ? ' ' : '') + initialClassValues[i];\n      }\n    }\n    context[StylingIndex.CachedClassValueOrInitialClassString] = className;\n  }\n  return className;\n}\n"]}