@angular/core 7.2.0-rc.0 → 7.2.0

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

@@ -1,132 +1,379 @@
+import * as tslib_1 from "tslib";
+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';
-var EMPTY_ARR = [];
-var 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`).
+ * This file includes the code to power all styling-binding operations in Angular.
  *
- * @param initialStyleDeclarations a list of style declarations and initial style values
- *    that are used later within the styling context.
+ * These include:
+ * [style]="myStyleObj"
+ * [class]="myClassObj"
+ * [style.prop]="myPropValue"
+ * [class.name]="myClassValue"
  *
- *    -> ['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`.
+ * 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.
+ */
+export function initializeStaticContext(attrs) {
+    var context = createEmptyStylingContext();
+    var initialClasses = context[3 /* InitialClassValuesPosition */] =
+        [null];
+    var 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.
+    var mode = -1;
+    for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i];
+        if (typeof attr == 'number') {
+            mode = attr;
+        }
+        else if (mode === 2 /* Styles */) {
+            initialStyles.push(attr, attrs[++i]);
+        }
+        else if (mode === 1 /* Classes */) {
+            initialClasses.push(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 initialClassDeclarations a list of class declarations and initial class values
- *    that are used later within the styling context.
+ * @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.
+ */
+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).
+    var 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);
+        var initialClasses = null;
+        var initialStyles = null;
+        var mode = -1;
+        for (var i = 0; i < attrs.length; i++) {
+            var attr = attrs[i];
+            if (typeof attr == 'number') {
+                mode = attr;
+            }
+            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]);
+            }
+        }
+    }
+}
+/**
+ * Designed to add a style or class value into the existing set of initial styles.
  *
- *    -> ['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
+ * 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.
  */
-export function createStylingContextTemplate(initialClassDeclarations, initialStyleDeclarations, styleSanitizer, onlyProcessSingleClasses) {
-    var initialStylingValues = [null];
-    var context = createEmptyStylingContext(null, styleSanitizer, initialStylingValues);
-    // we use two maps since a class name might collide with a CSS style prop
-    var stylesLookup = {};
-    var classesLookup = {};
-    var totalStyleDeclarations = 0;
-    if (initialStyleDeclarations) {
-        var hasPassedDeclarations = false;
-        for (var i = 0; i < initialStyleDeclarations.length; i++) {
-            var v = initialStyleDeclarations[i];
-            // this flag value marks where the declarations end the initial values begin
-            if (v === 1 /* VALUES_MODE */) {
-                hasPassedDeclarations = true;
+function patchInitialStylingValue(initialStyling, prop, value) {
+    // Even values are keys; Odd numbers are values; Search keys only
+    for (var i = 1 /* KeyValueStartPosition */; i < initialStyling.length;) {
+        var key = initialStyling[i];
+        if (key === prop) {
+            var 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.
+ */
+export function renderInitialStylesAndClasses(element, context, renderer) {
+    var initialClasses = context[3 /* InitialClassValuesPosition */];
+    renderInitialStylingValues(element, renderer, initialClasses, true);
+    var 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.
+ */
+function renderInitialStylingValues(element, renderer, initialStylingValues, isEntryClassBased) {
+    for (var i = 1 /* KeyValueStartPosition */; i < initialStylingValues.length; i += 2 /* Size */) {
+        var value = initialStylingValues[i + 1 /* ValueOffset */];
+        if (value) {
+            if (isEntryClassBased) {
+                setClass(element, initialStylingValues[i + 0 /* PropOffset */], true, renderer, null);
             }
             else {
-                var prop = v;
-                if (hasPassedDeclarations) {
-                    var value = initialStyleDeclarations[++i];
-                    initialStylingValues.push(value);
-                    stylesLookup[prop] = initialStylingValues.length - 1;
-                }
-                else {
-                    totalStyleDeclarations++;
-                    stylesLookup[prop] = 0;
-                }
+                setStyle(element, initialStylingValues[i + 0 /* PropOffset */], value, renderer, null);
             }
         }
     }
-    // make where the class offsets begin
-    context[4 /* ClassOffsetPosition */] = totalStyleDeclarations;
-    var initialStaticClasses = onlyProcessSingleClasses ? [] : null;
-    if (initialClassDeclarations) {
-        var hasPassedDeclarations = false;
-        for (var i = 0; i < initialClassDeclarations.length; i++) {
-            var v = initialClassDeclarations[i];
-            // this flag value marks where the declarations end the initial values begin
-            if (v === 1 /* VALUES_MODE */) {
-                hasPassedDeclarations = true;
+}
+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.
+ */
+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
+    var 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.
+    var singlePropOffsetValues = context[4 /* SinglePropOffsetPositions */];
+    var totalCurrentClassBindings = singlePropOffsetValues[1 /* ClassesCountPosition */];
+    var totalCurrentStyleBindings = singlePropOffsetValues[0 /* StylesCountPosition */];
+    var classesOffset = totalCurrentClassBindings * 4 /* Size */;
+    var stylesOffset = totalCurrentStyleBindings * 4 /* Size */;
+    var singleStylesStartIndex = 9 /* SingleStylesStartPosition */;
+    var singleClassesStartIndex = singleStylesStartIndex + stylesOffset;
+    var multiStylesStartIndex = singleClassesStartIndex + classesOffset;
+    var 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.
+    var 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
+    var insertionOffset = 0;
+    var filteredStyleBindingNames = [];
+    if (styleBindingNames && styleBindingNames.length) {
+        for (var i_1 = 0; i_1 < styleBindingNames.length; i_1++) {
+            var name_1 = styleBindingNames[i_1];
+            var singlePropIndex = getMatchingBindingIndex(context, name_1, singleStylesStartIndex, singleClassesStartIndex);
+            if (singlePropIndex == -1) {
+                singlePropIndex = singleClassesStartIndex + insertionOffset;
+                insertionOffset += 4 /* Size */;
+                filteredStyleBindingNames.push(name_1);
+            }
+            singlePropOffsetValues.push(singlePropIndex);
+        }
+    }
+    // just like with the style binding loop above, the new class bindings get the same treatment...
+    var filteredClassBindingNames = [];
+    if (classBindingNames && classBindingNames.length) {
+        for (var i_2 = 0; i_2 < classBindingNames.length; i_2++) {
+            var name_2 = classBindingNames[i_2];
+            var singlePropIndex = getMatchingBindingIndex(context, name_2, singleClassesStartIndex, multiStylesStartIndex);
+            if (singlePropIndex == -1) {
+                singlePropIndex = multiStylesStartIndex + insertionOffset;
+                insertionOffset += 4 /* Size */;
+                filteredClassBindingNames.push(name_2);
             }
             else {
-                var className = v;
-                if (hasPassedDeclarations) {
-                    var value = initialClassDeclarations[++i];
-                    initialStylingValues.push(value);
-                    classesLookup[className] = initialStylingValues.length - 1;
-                    initialStaticClasses && initialStaticClasses.push(className);
-                }
-                else {
-                    classesLookup[className] = 0;
+                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.
+    var i = 2 /* ValueStartPosition */;
+    if (filteredStyleBindingNames.length) {
+        while (i < currentSinglePropsLength) {
+            var totalStyles = singlePropOffsetValues[i + 0 /* StylesCountPosition */];
+            var totalClasses = singlePropOffsetValues[i + 1 /* ClassesCountPosition */];
+            if (totalClasses) {
+                var start = i + 2 /* ValueStartPosition */ + totalStyles;
+                for (var j = start; j < start + totalClasses; j++) {
+                    singlePropOffsetValues[j] += filteredStyleBindingNames.length * 4 /* Size */;
                 }
             }
+            var total = totalStyles + totalClasses;
+            i += 2 /* ValueStartPosition */ + total;
+        }
+    }
+    var 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 (var i_3 = singleStylesStartIndex; i_3 < context.length; i_3 += 4 /* Size */) {
+        var isMultiBased = i_3 >= multiStylesStartIndex;
+        var isClassBased = i_3 >= (isMultiBased ? multiClassesStartIndex : singleClassesStartIndex);
+        var flag = getPointers(context, i_3);
+        var staticIndex = getInitialIndex(flag);
+        var 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_3, pointers(flag, staticIndex, singleOrMultiIndex));
     }
-    var styleProps = Object.keys(stylesLookup);
-    var classNames = Object.keys(classesLookup);
-    var classNamesIndexStart = styleProps.length;
-    var totalProps = styleProps.length + classNames.length;
-    // *2 because we are filling for both single and multi style spaces
-    var 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 (var i = 8 /* SingleStylesStartPosition */; i < maxLength; i++) {
+    // this is where we make space in the context for the new style bindings
+    for (var i_4 = 0; i_4 < filteredStyleBindingNames.length * 4 /* Size */; i_4++) {
+        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 (var i_5 = 0; i_5 < filteredClassBindingNames.length * 4 /* Size */; i_5++) {
+        context.splice(multiStylesStartIndex, 0, null);
         context.push(null);
+        multiStylesStartIndex++;
+        multiClassesStartIndex++;
     }
-    var singleStart = 8 /* SingleStylesStartPosition */;
-    var multiStart = totalProps * 4 /* Size */ + 8 /* SingleStylesStartPosition */;
-    // fill single and multi-level styles
-    for (var i = 0; i < totalProps; i++) {
-        var isClassBased_1 = i >= classNamesIndexStart;
-        var prop = isClassBased_1 ? classNames[i - classNamesIndexStart] : styleProps[i];
-        var indexForInitial = isClassBased_1 ? classesLookup[prop] : stylesLookup[prop];
-        var initialValue = initialStylingValues[indexForInitial];
-        var indexForMulti = i * 4 /* Size */ + multiStart;
-        var indexForSingle = i * 4 /* Size */ + singleStart;
-        var initialFlag = prepareInitialFlag(prop, isClassBased_1, styleSanitizer || null);
-        setFlag(context, indexForSingle, pointers(initialFlag, indexForInitial, indexForMulti));
-        setProp(context, indexForSingle, prop);
-        setValue(context, indexForSingle, null);
-        setPlayerBuilderIndex(context, indexForSingle, 0);
-        var 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);
+    var initialClasses = context[3 /* InitialClassValuesPosition */];
+    var 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 (var i_6 = 0; i_6 < totalNewEntries; i_6++) {
+        var entryIsClassBased = i_6 >= filteredStyleBindingNames.length;
+        var adjustedIndex = entryIsClassBased ? (i_6 - filteredStyleBindingNames.length) : i_6;
+        var propName = entryIsClassBased ? filteredClassBindingNames[adjustedIndex] :
+            filteredStyleBindingNames[adjustedIndex];
+        var multiIndex = void 0, singleIndex = void 0;
+        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.
+        var initialValuesToLookup = entryIsClassBased ? initialClasses : initialStyles;
+        var indexForInitial = getInitialStylingValuesIndexOf(initialValuesToLookup, propName);
+        if (indexForInitial === -1) {
+            indexForInitial = initialValuesToLookup.length + 1 /* ValueOffset */;
+            initialValuesToLookup.push(propName, entryIsClassBased ? false : null);
+        }
+        else {
+            indexForInitial += 1 /* ValueOffset */;
+        }
+        var 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);
     }
+    // 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
-    var masterFlag = pointers(0, 0, multiStart) |
+    var 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
+ */
+function findOrPatchDirectiveIntoRegistry(context, directiveRef, styleSanitizer) {
+    var directiveRefs = context[1 /* DirectiveRegistryPosition */];
+    var nextOffsetInsertionIndex = context[4 /* SinglePropOffsetPositions */].length;
+    var directiveIndex;
+    var detectedIndex = getDirectiveRegistryValuesIndexOf(directiveRefs, directiveRef);
+    if (detectedIndex === -1) {
+        directiveIndex = directiveRefs.length / 4 /* Size */;
+        directiveRefs.push(directiveRef, nextOffsetInsertionIndex, false, styleSanitizer || null);
     }
-    return context;
+    else {
+        var singlePropStartPosition = detectedIndex + 1 /* SinglePropValuesIndexOffset */;
+        if (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.
+        var singlePropPositionIndex = detectedIndex + 1 /* SinglePropValuesIndexOffset */;
+        directiveRefs[singlePropPositionIndex] = nextOffsetInsertionIndex;
+        // the sanitizer is also apart of the binding process and will be used when bindings are
+        // applied.
+        var styleSanitizerIndex = detectedIndex + 3 /* StyleSanitizerOffset */;
+        directiveRefs[styleSanitizerIndex] = styleSanitizer || null;
+    }
+    return directiveIndex;
+}
+function getMatchingBindingIndex(context, bindingName, start, end) {
+    for (var 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
@@ -137,8 +384,9 @@ export function createStylingContextTemplate(initialClassDeclarations, initialSt
  * @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.
  */
-export function updateStylingMap(context, classesInput, stylesInput) {
+export function updateStylingMap(context, classesInput, stylesInput, directiveRef) {
     stylesInput = stylesInput || null;
+    var directiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);
     var element = context[5 /* ElementPosition */];
     var classesPlayerBuilder = classesInput instanceof BoundPlayerFactory ?
         new ClassAndStylePlayerBuilder(classesInput, element, 1 /* Class */) :
@@ -152,13 +400,13 @@ export function updateStylingMap(context, classesInput, stylesInput) {
     var stylesValue = stylesPlayerBuilder ? stylesInput.value : stylesInput;
     // early exit (this is what's done to avoid using ctx.bind() to cache the value)
     var ignoreAllClassUpdates = limitToSingleClasses(context) || classesValue === NO_CHANGE ||
-        classesValue === context[6 /* PreviousOrCachedMultiClassValue */];
-    var ignoreAllStyleUpdates = stylesValue === NO_CHANGE || stylesValue === context[7 /* PreviousMultiStyleValue */];
+        classesValue === context[6 /* CachedClassValueOrInitialClassString */];
+    var ignoreAllStyleUpdates = stylesValue === NO_CHANGE || stylesValue === context[7 /* CachedStyleValue */];
     if (ignoreAllClassUpdates && ignoreAllStyleUpdates)
         return;
-    context[6 /* PreviousOrCachedMultiClassValue */] = classesValue;
-    context[7 /* PreviousMultiStyleValue */] = stylesValue;
-    var classNames = EMPTY_ARR;
+    context[6 /* CachedClassValueOrInitialClassString */] = classesValue;
+    context[7 /* CachedStyleValue */] = stylesValue;
+    var classNames = EMPTY_ARRAY;
     var applyAllClasses = false;
     var playerBuildersAreDirty = false;
     var classesPlayerBuilderIndex = classesPlayerBuilder ? 1 /* ClassMapPlayerBuilderPosition */ : 0;
@@ -181,11 +429,11 @@ export function updateStylingMap(context, classesInput, stylesInput) {
             applyAllClasses = true;
         }
         else {
-            classNames = classesValue ? Object.keys(classesValue) : EMPTY_ARR;
+            classNames = classesValue ? Object.keys(classesValue) : EMPTY_ARRAY;
         }
     }
     var classes = (classesValue || EMPTY_OBJ);
-    var styleProps = stylesValue ? Object.keys(stylesValue) : EMPTY_ARR;
+    var styleProps = stylesValue ? Object.keys(stylesValue) : EMPTY_ARRAY;
     var styles = stylesValue || EMPTY_OBJ;
     var classesStartIndex = styleProps.length;
     var multiStartIndex = getMultiStartIndex(context);
@@ -197,27 +445,31 @@ export function updateStylingMap(context, classesInput, stylesInput) {
     // styles differ with respect to the context. Later if the context/styles/classes
     // are off-balance then they will be dealt in another loop after this one
     while (ctxIndex < context.length && propIndex < propLimit) {
-        var isClassBased_2 = propIndex >= classesStartIndex;
-        var processValue = (!isClassBased_2 && !ignoreAllStyleUpdates) || (isClassBased_2 && !ignoreAllClassUpdates);
+        var isClassBased = propIndex >= classesStartIndex;
+        var processValue = (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);
         // when there is a cache-hit for a string-based class then we should
         // avoid doing any work diffing any of the changes
         if (processValue) {
-            var adjustedPropIndex = isClassBased_2 ? propIndex - classesStartIndex : propIndex;
-            var newProp = isClassBased_2 ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];
-            var newValue = isClassBased_2 ? (applyAllClasses ? true : classes[newProp]) : styles[newProp];
-            var playerBuilderIndex = isClassBased_2 ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
+            var adjustedPropIndex = isClassBased ? propIndex - classesStartIndex : propIndex;
+            var newProp = isClassBased ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];
+            var newValue = isClassBased ? (applyAllClasses ? true : classes[newProp]) : styles[newProp];
+            var playerBuilderIndex = isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
             var prop = getProp(context, ctxIndex);
             if (prop === newProp) {
                 var value = getValue(context, ctxIndex);
                 var 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;
                     var 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;
                     }
@@ -233,7 +485,8 @@ export function updateStylingMap(context, classesInput, stylesInput) {
                     if (hasValueChanged(flagToCompare, valueToCompare, newValue)) {
                         var 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;
@@ -242,9 +495,9 @@ export function updateStylingMap(context, classesInput, stylesInput) {
                 }
                 else {
                     // we only care to do this if the insertion is in the middle
-                    var newFlag = prepareInitialFlag(newProp, isClassBased_2, getStyleSanitizer(context));
+                    var newFlag = prepareInitialFlag(context, newProp, isClassBased, getStyleSanitizer(context, directiveIndex));
                     playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;
-                    insertNewMultiProperty(context, ctxIndex, isClassBased_2, newProp, newFlag, newValue, playerBuilderIndex);
+                    insertNewMultiProperty(context, ctxIndex, isClassBased, newProp, newFlag, newValue, directiveIndex, playerBuilderIndex);
                     dirty = true;
                 }
             }
@@ -257,19 +510,19 @@ export function updateStylingMap(context, classesInput, stylesInput) {
     // case the  goal is to "remove" them from the context (by nullifying)
     while (ctxIndex < context.length) {
         var flag = getPointers(context, ctxIndex);
-        var isClassBased_3 = (flag & 2 /* Class */) === 2 /* Class */;
-        var processValue = (!isClassBased_3 && !ignoreAllStyleUpdates) || (isClassBased_3 && !ignoreAllClassUpdates);
+        var isClassBased = (flag & 2 /* Class */) === 2 /* Class */;
+        var processValue = (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);
         if (processValue) {
             var value = getValue(context, ctxIndex);
-            var doRemoveValue = valueExists(value, isClassBased_3);
+            var doRemoveValue = valueExists(value, isClassBased);
             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.
-                var playerBuilderIndex = isClassBased_3 ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
-                setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex);
+                var playerBuilderIndex = isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
+                setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex, directiveIndex);
                 dirty = true;
             }
         }
@@ -278,31 +531,46 @@ export function updateStylingMap(context, classesInput, stylesInput) {
     // 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
-    var sanitizer = getStyleSanitizer(context);
+    var sanitizer = getStyleSanitizer(context, directiveIndex);
     while (propIndex < propLimit) {
-        var isClassBased_4 = propIndex >= classesStartIndex;
-        var processValue = (!isClassBased_4 && !ignoreAllStyleUpdates) || (isClassBased_4 && !ignoreAllClassUpdates);
+        var isClassBased = propIndex >= classesStartIndex;
+        var processValue = (!isClassBased && !ignoreAllStyleUpdates) || (isClassBased && !ignoreAllClassUpdates);
         if (processValue) {
-            var adjustedPropIndex = isClassBased_4 ? propIndex - classesStartIndex : propIndex;
-            var prop = isClassBased_4 ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];
-            var value = isClassBased_4 ? (applyAllClasses ? true : classes[prop]) : styles[prop];
-            var flag = prepareInitialFlag(prop, isClassBased_4, sanitizer) | 1 /* Dirty */;
-            var playerBuilderIndex = isClassBased_4 ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
-            context.push(flag, prop, value, playerBuilderIndex);
+            var adjustedPropIndex = isClassBased ? propIndex - classesStartIndex : propIndex;
+            var prop = isClassBased ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];
+            var value = isClassBased ? (applyAllClasses ? true : classes[prop]) : styles[prop];
+            var flag = prepareInitialFlag(context, prop, isClassBased, sanitizer) | 1 /* Dirty */;
+            var playerBuilderIndex = isClassBased ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;
+            var ctxIndex_1 = context.length;
+            context.push(flag, prop, value, 0);
+            setPlayerBuilderIndex(context, ctxIndex_1, 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
+ */
+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
@@ -311,20 +579,29 @@ 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 value The CSS style value that will be assigned
+ * @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).
  */
-export function updateStyleProp(context, index, input) {
-    var singleIndex = 8 /* SingleStylesStartPosition */ + index * 4 /* Size */;
+export function updateStyleProp(context, offset, input, directiveRef) {
+    _updateSingleStylingValue(context, offset, input, false, directiveRef);
+}
+function _updateSingleStylingValue(context, offset, input, isClassBased, directiveRef) {
+    var directiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);
+    var singleIndex = getSinglePropIndexValue(context, directiveIndex, offset, isClassBased);
     var currValue = getValue(context, singleIndex);
     var currFlag = getPointers(context, singleIndex);
+    var currDirective = getDirectiveIndexFromEntry(context, singleIndex);
     var value = (input instanceof BoundPlayerFactory) ? input.value : input;
-    // didn't change ... nothing to make a note of
-    if (hasValueChanged(currFlag, currValue, value)) {
-        var isClassBased_5 = (currFlag & 2 /* Class */) === 2 /* Class */;
+    if (hasValueChanged(currFlag, currValue, value) &&
+        allowValueChange(currValue, value, currDirective, directiveIndex)) {
+        var isClassBased_1 = (currFlag & 2 /* Class */) === 2 /* Class */;
         var element = context[5 /* ElementPosition */];
         var playerBuilder = input instanceof BoundPlayerFactory ?
-            new ClassAndStylePlayerBuilder(input, element, isClassBased_5 ? 1 /* Class */ : 2 /* Style */) :
+            new ClassAndStylePlayerBuilder(input, element, isClassBased_1 ? 1 /* Class */ : 2 /* Style */) :
             null;
         var value_1 = (playerBuilder ? input.value : input);
         var currPlayerIndex = getPlayerBuilderIndex(context, singleIndex);
@@ -333,9 +610,16 @@ export function updateStyleProp(context, index, input) {
         if (hasPlayerBuilderChanged(context, playerBuilder, currPlayerIndex)) {
             var 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) {
+            var prop = getProp(context, singleIndex);
+            var 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_1);
         var indexForMulti = getMultiOrSingleIndex(currFlag);
@@ -345,12 +629,13 @@ export function updateStyleProp(context, index, input) {
             var multiDirty = false;
             var singleDirty = true;
             // only when the value is set to `null` should the multi-value get flagged
-            if (!valueExists(value_1, isClassBased_5) && valueExists(valueForMulti, isClassBased_5)) {
+            if (!valueExists(value_1, isClassBased_1) && valueExists(valueForMulti, isClassBased_1)) {
                 multiDirty = true;
                 singleDirty = false;
             }
             setDirty(context, indexForMulti, multiDirty);
             setDirty(context, singleIndex, singleDirty);
+            setDirectiveDirty(context, directiveIndex, true);
             setContextDirty(context, true);
         }
         if (playerBuildersAreDirty) {
@@ -358,19 +643,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
- */
-export function updateClassProp(context, index, addOrRemove) {
-    var adjustedIndex = index + context[4 /* ClassOffsetPosition */];
-    updateStyleProp(context, adjustedIndex, addOrRemove);
-}
 /**
  * Renders all queued styling using a renderer onto the given element.
  *
@@ -388,31 +660,41 @@ 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.
  * @returns 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) {
     var totalPlayersQueued = 0;
-    if (isContextDirty(context)) {
-        var flushPlayerBuilders = context[3 /* MasterFlagPosition */] & 8 /* PlayerBuildersDirty */;
+    var targetDirectiveIndex = getDirectiveIndexFromRegistry(context, directiveRef || null);
+    if (isContextDirty(context) && isDirectiveDirty(context, targetDirectiveIndex)) {
+        var flushPlayerBuilders = context[0 /* MasterFlagPosition */] & 8 /* PlayerBuildersDirty */;
         var native = context[5 /* ElementPosition */];
         var multiStartIndex = getMultiStartIndex(context);
-        var styleSanitizer = getStyleSanitizer(context);
         var onlySingleClasses = limitToSingleClasses(context);
-        for (var i = 8 /* SingleStylesStartPosition */; i < context.length; i += 4 /* Size */) {
+        var stillDirty = false;
+        for (var 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)) {
+                var flag = getPointers(context, i);
+                var directiveIndex = getDirectiveIndexFromEntry(context, i);
+                if (targetDirectiveIndex !== directiveIndex) {
+                    stillDirty = true;
+                    continue;
+                }
                 var prop = getProp(context, i);
                 var value = getValue(context, i);
-                var flag = getPointers(context, i);
+                var styleSanitizer = (flag & 4 /* Sanitize */) ? getStyleSanitizer(context, directiveIndex) : null;
                 var playerBuilder = getPlayerBuilder(context, i);
-                var isClassBased_6 = flag & 2 /* Class */ ? true : false;
+                var isClassBased = flag & 2 /* Class */ ? true : false;
                 var isInSingleRegion = i < multiStartIndex;
-                var readInitialValue = !isClassBased_6 || !onlySingleClasses;
+                var readInitialValue = !isClassBased || !onlySingleClasses;
                 var valueToApply = value;
                 // VALUE DEFER CASE 1: Use a multi value instead of a null single value
                 // 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_6)) {
+                if (isInSingleRegion && !valueExists(valueToApply, isClassBased)) {
                     // single values ALWAYS have a reference to a multi index
                     var multiIndex = getMultiOrSingleIndex(flag);
                     valueToApply = getValue(context, multiIndex);
@@ -423,7 +705,9 @@ 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_6) && 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
@@ -432,12 +716,11 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
                 // was truthy before.
                 var doApplyValue = isFirstRender ? valueToApply : true;
                 if (doApplyValue) {
-                    if (isClassBased_6) {
+                    if (isClassBased) {
                         setClass(native, prop, valueToApply ? true : false, renderer, classesStore, playerBuilder);
                     }
                     else {
-                        var sanitizer = (flag & 4 /* Sanitize */) ? styleSanitizer : null;
-                        setStyle(native, prop, valueToApply, renderer, sanitizer, stylesStore, playerBuilder);
+                        setStyle(native, prop, valueToApply, renderer, styleSanitizer, stylesStore, playerBuilder);
                     }
                 }
                 setDirty(context, i, false);
@@ -471,7 +754,8 @@ export function renderStyleAndClassBindings(context, renderer, rootOrView, isFir
             }
             setContextPlayersDirty(context, false);
         }
-        setContextDirty(context, false);
+        setDirectiveDirty(context, targetDirectiveIndex, false);
+        setContextDirty(context, stillDirty);
     }
     return totalPlayersQueued;
 }
@@ -498,6 +782,8 @@ export function setStyle(native, prop, value, renderer, sanitizer, store, player
         }
     }
     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) :
@@ -542,8 +828,16 @@ function setClass(native, className, add, renderer, store, playerBuilder) {
             native['classList'].remove(className);
     }
 }
+function setSanitizeFlag(context, index, sanitizeYes) {
+    if (sanitizeYes) {
+        context[index] |= 4 /* Sanitize */;
+    }
+    else {
+        context[index] &= ~4 /* Sanitize */;
+    }
+}
 function setDirty(context, index, isDirtyYes) {
-    var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+    var adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
     if (isDirtyYes) {
         context[adjustedIndex] |= 1 /* Dirty */;
     }
@@ -552,37 +846,37 @@ function setDirty(context, index, isDirtyYes) {
     }
 }
 function isDirty(context, index) {
-    var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+    var adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
     return (context[adjustedIndex] & 1 /* Dirty */) == 1 /* Dirty */;
 }
-export function isClassBased(context, index) {
-    var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+export function isClassBasedValue(context, index) {
+    var adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
     return (context[adjustedIndex] & 2 /* Class */) == 2 /* Class */;
 }
 function isSanitizable(context, index) {
-    var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
+    var adjustedIndex = index >= 9 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;
     return (context[adjustedIndex] & 4 /* Sanitize */) == 4 /* Sanitize */;
 }
 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 */));
 }
 function getInitialValue(context, flag) {
     var index = getInitialIndex(flag);
-    return context[2 /* InitialStylesPosition */][index];
+    var entryIsClassBased = flag & 2 /* Class */;
+    var initialValues = entryIsClassBased ? context[3 /* InitialClassValuesPosition */] :
+        context[2 /* InitialStyleValuesPosition */];
+    return initialValues[index];
 }
 function getInitialIndex(flag) {
-    return (flag >> 5 /* BitCountSize */) & 16383 /* BitMask */;
+    return (flag >> 6 /* BitCountSize */) & 16383 /* BitMask */;
 }
 function getMultiOrSingleIndex(flag) {
-    var index = (flag >> (14 /* BitCountSize */ + 5 /* BitCountSize */)) & 16383 /* BitMask */;
-    return index >= 8 /* SingleStylesStartPosition */ ? index : -1;
+    var index = (flag >> (14 /* BitCountSize */ + 6 /* BitCountSize */)) & 16383 /* BitMask */;
+    return index >= 9 /* SingleStylesStartPosition */ ? index : -1;
 }
 function getMultiStartIndex(context) {
-    return getMultiOrSingleIndex(context[3 /* MasterFlagPosition */]);
-}
-function getStyleSanitizer(context) {
-    return context[1 /* StyleSanitizerPosition */];
+    return getMultiOrSingleIndex(context[0 /* MasterFlagPosition */]);
 }
 function setProp(context, index, prop) {
     context[index + 1 /* PropertyOffset */] = prop;
@@ -591,7 +885,7 @@ function setValue(context, index, value) {
     context[index + 2 /* ValueOffset */] = value;
 }
 function hasPlayerBuilderChanged(context, builder, index) {
-    var playerContext = context[0 /* PlayerContext */];
+    var playerContext = context[8 /* PlayerContext */];
     if (builder) {
         if (!playerContext || index === 0) {
             return true;
@@ -603,7 +897,7 @@ function hasPlayerBuilderChanged(context, builder, index) {
     return playerContext[index] !== builder;
 }
 function setPlayerBuilder(context, builder, insertionIndex) {
-    var playerContext = context[0 /* PlayerContext */] || allocPlayerContext(context);
+    var playerContext = context[8 /* PlayerContext */] || allocPlayerContext(context);
     if (insertionIndex > 0) {
         playerContext[insertionIndex] = builder;
     }
@@ -615,16 +909,23 @@ function setPlayerBuilder(context, builder, insertionIndex) {
     }
     return insertionIndex;
 }
-function setPlayerBuilderIndex(context, index, playerBuilderIndex) {
-    context[index + 3 /* PlayerBuilderIndexOffset */] = playerBuilderIndex;
+export function directiveOwnerPointers(directiveIndex, playerIndex) {
+    return (playerIndex << 16 /* BitCountSize */) | directiveIndex;
+}
+function setPlayerBuilderIndex(context, index, playerBuilderIndex, directiveIndex) {
+    var value = directiveOwnerPointers(directiveIndex, playerBuilderIndex);
+    context[index + 3 /* PlayerBuilderIndexOffset */] = value;
 }
 function getPlayerBuilderIndex(context, index) {
-    return context[index + 3 /* PlayerBuilderIndexOffset */] || 0;
+    var flag = context[index + 3 /* PlayerBuilderIndexOffset */];
+    var playerBuilderIndex = (flag >> 16 /* BitCountSize */) &
+        65535 /* BitMask */;
+    return playerBuilderIndex;
 }
 function getPlayerBuilder(context, index) {
     var playerBuilderIndex = getPlayerBuilderIndex(context, index);
     if (playerBuilderIndex) {
-        var playerContext = context[0 /* PlayerContext */];
+        var playerContext = context[8 /* PlayerContext */];
         if (playerContext) {
             return playerContext[playerBuilderIndex];
         }
@@ -632,11 +933,11 @@ function getPlayerBuilder(context, index) {
     return null;
 }
 function setFlag(context, index, flag) {
-    var adjustedIndex = index === 3 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
+    var adjustedIndex = index === 0 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
     context[adjustedIndex] = flag;
 }
 function getPointers(context, index) {
-    var adjustedIndex = index === 3 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
+    var adjustedIndex = index === 0 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);
     return context[adjustedIndex];
 }
 export function getValue(context, index) {
@@ -646,20 +947,20 @@ export function getProp(context, index) {
     return context[index + 1 /* PropertyOffset */];
 }
 export function isContextDirty(context) {
-    return isDirty(context, 3 /* MasterFlagPosition */);
+    return isDirty(context, 0 /* MasterFlagPosition */);
 }
 export function limitToSingleClasses(context) {
-    return context[3 /* MasterFlagPosition */] & 16 /* OnlyProcessSingleClasses */;
+    return context[0 /* MasterFlagPosition */] & 16 /* OnlyProcessSingleClasses */;
 }
 export function setContextDirty(context, isDirtyYes) {
-    setDirty(context, 3 /* MasterFlagPosition */, isDirtyYes);
+    setDirty(context, 0 /* MasterFlagPosition */, isDirtyYes);
 }
 export function setContextPlayersDirty(context, isDirtyYes) {
     if (isDirtyYes) {
-        context[3 /* MasterFlagPosition */] |= 8 /* PlayerBuildersDirty */;
+        context[0 /* MasterFlagPosition */] |= 8 /* PlayerBuildersDirty */;
     }
     else {
-        context[3 /* MasterFlagPosition */] &= ~8 /* PlayerBuildersDirty */;
+        context[0 /* MasterFlagPosition */] &= ~8 /* PlayerBuildersDirty */;
     }
 }
 function findEntryPositionByProp(context, prop, startIndex) {
@@ -693,11 +994,13 @@ 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));
+    var playerIndexA = getPlayerBuilderIndex(context, indexB);
+    var 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);
 }
 function updateSinglePointerValues(context, indexStartPosition) {
     for (var i = indexStartPosition; i < context.length; i += 4 /* Size */) {
@@ -707,17 +1010,18 @@ function updateSinglePointerValues(context, indexStartPosition) {
             var singleFlag = getPointers(context, singleIndex);
             var initialIndexForSingle = getInitialIndex(singleFlag);
             var 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 */);
             var updatedFlag = pointers(flagValue, initialIndexForSingle, i);
             setFlag(context, singleIndex, updatedFlag);
         }
     }
 }
-function insertNewMultiProperty(context, index, classBased, name, flag, value, playerIndex) {
+function insertNewMultiProperty(context, index, classBased, name, flag, value, directiveIndex, playerIndex) {
     var 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
@@ -731,14 +1035,20 @@ function valueExists(value, isClassBased) {
     }
     return value !== null;
 }
-function prepareInitialFlag(name, isClassBased, sanitizer) {
-    if (isClassBased) {
-        return 2 /* Class */;
+function prepareInitialFlag(context, prop, entryIsClassBased, sanitizer) {
+    var flag = (sanitizer && sanitizer(prop)) ? 4 /* Sanitize */ : 0 /* None */;
+    var 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);
 }
 function hasValueChanged(flag, a, b) {
     var isClassBased = flag & 2 /* Class */;
@@ -783,4 +1093,165 @@ var ClassAndStylePlayerBuilder = /** @class */ (function () {
     return ClassAndStylePlayerBuilder;
 }());
 export { ClassAndStylePlayerBuilder };
-//# 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 {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\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 | LView,\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 */\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    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\nexport function 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\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  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"]}
+export function generateConfigSummary(source, index) {
+    var flag, name = 'config value for ';
+    if (Array.isArray(source)) {
+        if (index) {
+            name += 'index: ' + index;
+        }
+        else {
+            name += 'master config';
+        }
+        index = index || 0 /* MasterFlagPosition */;
+        flag = source[index];
+    }
+    else {
+        flag = source;
+        name += 'index: ' + flag;
+    }
+    var dynamicIndex = getMultiOrSingleIndex(flag);
+    var staticIndex = getInitialIndex(flag);
+    return {
+        name: name,
+        staticIndex: staticIndex,
+        dynamicIndex: 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,
+        }
+    };
+}
+export function getDirectiveIndexFromEntry(context, index) {
+    var value = context[index + 3 /* PlayerBuilderIndexOffset */];
+    return value & 65535 /* BitMask */;
+}
+function getDirectiveIndexFromRegistry(context, directive) {
+    var 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;
+}
+function getDirectiveRegistryValuesIndexOf(directives, directive) {
+    for (var i = 0; i < directives.length; i += 4 /* Size */) {
+        if (directives[i] === directive) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInitialStylingValuesIndexOf(keyValues, key) {
+    for (var i = 1 /* KeyValueStartPosition */; i < keyValues.length; i += 2 /* Size */) {
+        if (keyValues[i] === key)
+            return i;
+    }
+    return -1;
+}
+export function compareLogSummaries(a, b) {
+    var log = [];
+    var diffs = [];
+    diffSummaryValues(diffs, 'staticIndex', 'staticIndex', a, b);
+    diffSummaryValues(diffs, 'dynamicIndex', 'dynamicIndex', a, b);
+    Object.keys(a.flags).forEach(function (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(function (result) {
+            var _a = tslib_1.__read(result, 3), name = _a[0], aVal = _a[1], bVal = _a[2];
+            log.push('    => ' + name);
+            log.push('    => ' + aVal + ' !== ' + bVal + '\n');
+        });
+    }
+    return log;
+}
+function diffSummaryValues(result, name, prop, a, b) {
+    var aVal = a[prop];
+    var bVal = b[prop];
+    if (aVal !== bVal) {
+        result.push([name, aVal, bVal]);
+    }
+}
+function getSinglePropIndexValue(context, directiveIndex, offset, isClassBased) {
+    var singlePropOffsetRegistryIndex = context[1 /* DirectiveRegistryPosition */][(directiveIndex * 4 /* Size */) +
+        1 /* SinglePropValuesIndexOffset */];
+    var offsets = context[4 /* SinglePropOffsetPositions */];
+    var indexForOffset = singlePropOffsetRegistryIndex +
+        2 /* ValueStartPosition */ +
+        (isClassBased ?
+            offsets[singlePropOffsetRegistryIndex + 0 /* StylesCountPosition */] :
+            0) +
+        offset;
+    return offsets[indexForOffset];
+}
+function getStyleSanitizer(context, directiveIndex) {
+    var dirs = context[1 /* DirectiveRegistryPosition */];
+    var value = dirs[directiveIndex * 4 /* Size */ +
+        3 /* StyleSanitizerOffset */] ||
+        dirs[3 /* StyleSanitizerOffset */] || null;
+    return value;
+}
+function isDirectiveDirty(context, directiveIndex) {
+    var dirs = context[1 /* DirectiveRegistryPosition */];
+    return dirs[directiveIndex * 4 /* Size */ +
+        2 /* DirtyFlagOffset */];
+}
+function setDirectiveDirty(context, directiveIndex, dirtyYes) {
+    var dirs = context[1 /* DirectiveRegistryPosition */];
+    dirs[directiveIndex * 4 /* Size */ +
+        2 /* DirtyFlagOffset */] = dirtyYes;
+}
+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.
+ */
+export function getInitialClassNameValue(context) {
+    var className = context[6 /* CachedClassValueOrInitialClassString */];
+    if (className == null) {
+        className = '';
+        var initialClassValues = context[3 /* InitialClassValuesPosition */];
+        for (var i = 1 /* KeyValueStartPosition */; i < initialClassValues.length; i += 2 /* Size */) {
+            var 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":";AAQA,OAAO,EAAC,cAAc,EAAC,MAAM,WAAW,CAAC;AACzC,OAAO,EAAC,WAAW,EAAE,SAAS,EAAC,MAAM,UAAU,CAAC;AAGhD,OAAO,EAAsB,mBAAmB,EAAE,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAGtG,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,EAAC,cAAc,EAAC,MAAM,SAAS,CAAC;AAEvC,OAAO,EAAC,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAC,iBAAiB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,gBAAgB,EAAC,MAAM,QAAQ,CAAC;AAG1G;;;;;;;;;;;GAWG;AAIH;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAkB;IACxD,IAAM,OAAO,GAAG,yBAAyB,EAAE,CAAC;IAC5C,IAAM,cAAc,GAAyB,OAAO,oCAAyC;QACzF,CAAC,IAAI,CAAC,CAAC;IACX,IAAM,aAAa,GAAyB,OAAO,oCAAyC;QACxF,CAAC,IAAI,CAAC,CAAC;IAEX,kFAAkF;IAClF,2FAA2F;IAC3F,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACrC,IAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,OAAO,IAAI,IAAI,QAAQ,EAAE;YAC3B,IAAI,GAAG,IAAI,CAAC;SACb;aAAM,IAAI,IAAI,mBAA2B,EAAE;YAC1C,aAAa,CAAC,IAAI,CAAC,IAAc,EAAE,KAAK,CAAC,EAAE,CAAC,CAAW,CAAC,CAAC;SAC1D;aAAM,IAAI,IAAI,oBAA4B,EAAE;YAC3C,cAAc,CAAC,IAAI,CAAC,IAAc,EAAE,IAAI,CAAC,CAAC;SAC3C;aAAM,IAAI,IAAI,uBAA+B,EAAE;YAC9C,MAAM;SACP;KACF;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,2BAA2B,CACvC,OAAuB,EAAE,KAAkB,EAAE,SAAc;IAC7D,uFAAuF;IACvF,0FAA0F;IAC1F,4FAA4F;IAC5F,8FAA8F;IAC9F,IAAM,UAAU,GAAG,OAAO,mCAAwC,CAAC;IACnE,IAAI,iCAAiC,CAAC,UAAU,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE;QAClE,sDAAsD;QACtD,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAE5C,IAAI,cAAc,GAA8B,IAAI,CAAC;QACrD,IAAI,aAAa,GAA8B,IAAI,CAAC;QAEpD,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;QACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACrC,IAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,OAAO,IAAI,IAAI,QAAQ,EAAE;gBAC3B,IAAI,GAAG,IAAI,CAAC;aACb;iBAAM,IAAI,IAAI,mBAA2B,EAAE;gBAC1C,cAAc,GAAG,cAAc,IAAI,OAAO,oCAAyC,CAAC;gBACpF,wBAAwB,CAAC,cAAc,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;aACtD;iBAAM,IAAI,IAAI,kBAA0B,EAAE;gBACzC,aAAa,GAAG,aAAa,IAAI,OAAO,oCAAyC,CAAC;gBAClF,wBAAwB,CAAC,aAAa,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;aAC3D;SACF;KACF;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,wBAAwB,CAC7B,cAAoC,EAAE,IAAY,EAAE,KAAU;IAChE,iEAAiE;IACjE,KAAK,IAAI,CAAC,gCAAkD,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,GAAG;QACxF,IAAM,GAAG,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;QAC9B,IAAI,GAAG,KAAK,IAAI,EAAE;YAChB,IAAM,aAAa,GAAG,cAAc,CAAC,CAAC,sBAAwC,CAAC,CAAC;YAEhF,yEAAyE;YACzE,mEAAmE;YACnE,IAAI,aAAa,IAAI,IAAI,IAAI,aAAa,IAAI,KAAK,EAAE;gBACnD,cAAc,CAAC,CAAC,sBAAwC,CAAC,GAAG,KAAK,CAAC;aACnE;YACD,OAAO;SACR;QACD,CAAC,GAAG,CAAC,eAAiC,CAAC;KACxC;IACD,+CAA+C;IAC/C,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,6BAA6B,CACzC,OAAiB,EAAE,OAAuB,EAAE,QAAmB;IACjE,IAAM,cAAc,GAAG,OAAO,oCAAyC,CAAC;IACxE,0BAA0B,CAAC,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IAEpE,IAAM,aAAa,GAAG,OAAO,oCAAyC,CAAC;IACvE,0BAA0B,CAAC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;AACtE,CAAC;AAED;;;GAGG;AACH,SAAS,0BAA0B,CAC/B,OAAiB,EAAE,QAAmB,EAAE,oBAA0C,EAClF,iBAA0B;IAC5B,KAAK,IAAI,CAAC,gCAAkD,EAAE,CAAC,GAAG,oBAAoB,CAAC,MAAM,EACxF,CAAC,gBAAkC,EAAE;QACxC,IAAM,KAAK,GAAG,oBAAoB,CAAC,CAAC,sBAAwC,CAAC,CAAC;QAC9E,IAAI,KAAK,EAAE;YACT,IAAI,iBAAiB,EAAE;gBACrB,QAAQ,CACJ,OAAO,EAAE,oBAAoB,CAAC,CAAC,qBAAuC,CAAW,EAAE,IAAI,EACvF,QAAQ,EAAE,IAAI,CAAC,CAAC;aACrB;iBAAM;gBACL,QAAQ,CACJ,OAAO,EAAE,oBAAoB,CAAC,CAAC,qBAAuC,CAAW,EACjF,KAAe,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;aACtC;SACF;KACF;AACH,CAAC;AAED,MAAM,UAAU,iCAAiC,CAAC,OAAuB;IACvE,OAAO,CAAC,OAAO,4BAAiC,mCAAuC,CAAC,KAAK,CAAC,CAAC;AACjG,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,yBAAyB,CACrC,OAAuB,EAAE,YAAwB,EAAE,iBAAmC,EACtF,iBAAmC,EAAE,cAAuC,EAC5E,wBAAkC;IACpC,IAAI,OAAO,4BAAiC,mCAAuC;QAAE,OAAO;IAE5F,gFAAgF;IAChF,IAAM,cAAc,GAAG,gCAAgC,CAAC,OAAO,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;IAC/F,IAAI,cAAc,KAAK,CAAC,CAAC,EAAE;QACzB,sFAAsF;QACtF,OAAO;KACR;IAED,qFAAqF;IACrF,mFAAmF;IACnF,uFAAuF;IACvF,2FAA2F;IAC3F,mBAAmB;IACnB,IAAM,sBAAsB,GAAG,OAAO,mCAAwC,CAAC;IAC/E,IAAM,yBAAyB,GAC3B,sBAAsB,8BAAkD,CAAC;IAC7E,IAAM,yBAAyB,GAC3B,sBAAsB,6BAAiD,CAAC;IAE5E,IAAM,aAAa,GAAG,yBAAyB,eAAoB,CAAC;IACpE,IAAM,YAAY,GAAG,yBAAyB,eAAoB,CAAC;IAEnE,IAAM,sBAAsB,oCAAyC,CAAC;IACtE,IAAI,uBAAuB,GAAG,sBAAsB,GAAG,YAAY,CAAC;IACpE,IAAI,qBAAqB,GAAG,uBAAuB,GAAG,aAAa,CAAC;IACpE,IAAI,sBAAsB,GAAG,qBAAqB,GAAG,YAAY,CAAC;IAElE,8EAA8E;IAC9E,gFAAgF;IAChF,+EAA+E;IAC/E,qFAAqF;IACrF,mFAAmF;IACnF,sFAAsF;IACtF,qFAAqF;IACrF,qFAAqF;IACrF,IAAM,wBAAwB,GAAG,sBAAsB,CAAC,MAAM,CAAC;IAC/D,sBAAsB,CAAC,IAAI,CACvB,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAChD,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEtD,wFAAwF;IACxF,yFAAyF;IACzF,mEAAmE;IACnE,IAAI,eAAe,GAAG,CAAC,CAAC;IACxB,IAAM,yBAAyB,GAAa,EAAE,CAAC;IAC/C,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,MAAM,EAAE;QACjD,KAAK,IAAI,GAAC,GAAG,CAAC,EAAE,GAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,GAAC,EAAE,EAAE;YACjD,IAAM,MAAI,GAAG,iBAAiB,CAAC,GAAC,CAAC,CAAC;YAClC,IAAI,eAAe,GACf,uBAAuB,CAAC,OAAO,EAAE,MAAI,EAAE,sBAAsB,EAAE,uBAAuB,CAAC,CAAC;YAC5F,IAAI,eAAe,IAAI,CAAC,CAAC,EAAE;gBACzB,eAAe,GAAG,uBAAuB,GAAG,eAAe,CAAC;gBAC5D,eAAe,gBAAqB,CAAC;gBACrC,yBAAyB,CAAC,IAAI,CAAC,MAAI,CAAC,CAAC;aACtC;YACD,sBAAsB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SAC9C;KACF;IAED,gGAAgG;IAChG,IAAM,yBAAyB,GAAa,EAAE,CAAC;IAC/C,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,MAAM,EAAE;QACjD,KAAK,IAAI,GAAC,GAAG,CAAC,EAAE,GAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,GAAC,EAAE,EAAE;YACjD,IAAM,MAAI,GAAG,iBAAiB,CAAC,GAAC,CAAC,CAAC;YAClC,IAAI,eAAe,GACf,uBAAuB,CAAC,OAAO,EAAE,MAAI,EAAE,uBAAuB,EAAE,qBAAqB,CAAC,CAAC;YAC3F,IAAI,eAAe,IAAI,CAAC,CAAC,EAAE;gBACzB,eAAe,GAAG,qBAAqB,GAAG,eAAe,CAAC;gBAC1D,eAAe,gBAAqB,CAAC;gBACrC,yBAAyB,CAAC,IAAI,CAAC,MAAI,CAAC,CAAC;aACtC;iBAAM;gBACL,eAAe,IAAI,yBAAyB,CAAC,MAAM,eAAoB,CAAC;aACzE;YACD,sBAAsB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SAC9C;KACF;IAED,4FAA4F;IAC5F,+FAA+F;IAC/F,4FAA4F;IAC5F,oEAAoE;IACpE,IAAI,CAAC,6BAAiD,CAAC;IACvD,IAAI,yBAAyB,CAAC,MAAM,EAAE;QACpC,OAAO,CAAC,GAAG,wBAAwB,EAAE;YACnC,IAAM,WAAW,GACb,sBAAsB,CAAC,CAAC,8BAAkD,CAAC,CAAC;YAChF,IAAM,YAAY,GACd,sBAAsB,CAAC,CAAC,+BAAmD,CAAC,CAAC;YACjF,IAAI,YAAY,EAAE;gBAChB,IAAM,KAAK,GAAG,CAAC,6BAAiD,GAAG,WAAW,CAAC;gBAC/E,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;oBACjD,sBAAsB,CAAC,CAAC,CAAC,IAAI,yBAAyB,CAAC,MAAM,eAAoB,CAAC;iBACnF;aACF;YAED,IAAM,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;YACzC,CAAC,IAAI,6BAAiD,KAAK,CAAC;SAC7D;KACF;IAED,IAAM,eAAe,GAAG,yBAAyB,CAAC,MAAM,GAAG,yBAAyB,CAAC,MAAM,CAAC;IAE5F,4FAA4F;IAC5F,4FAA4F;IAC5F,yCAAyC;IACzC,KAAK,IAAI,GAAC,GAAG,sBAAsB,EAAE,GAAC,GAAG,OAAO,CAAC,MAAM,EAAE,GAAC,gBAAqB,EAAE;QAC/E,IAAM,YAAY,GAAG,GAAC,IAAI,qBAAqB,CAAC;QAChD,IAAM,YAAY,GAAG,GAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC;QAC5F,IAAM,IAAI,GAAG,WAAW,CAAC,OAAO,EAAE,GAAC,CAAC,CAAC;QACrC,IAAM,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,kBAAkB,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,YAAY,EAAE;YAChB,kBAAkB;gBACd,YAAY,CAAC,CAAC,CAAC,CAAC,yBAAyB,CAAC,MAAM,eAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/E;aAAM;YACL,kBAAkB,IAAI,CAAC,eAAe,eAAoB,CAAC;gBACvD,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,eAAoB,CAAC,CAAC;SACjF;QACD,OAAO,CAAC,OAAO,EAAE,GAAC,EAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,kBAAkB,CAAC,CAAC,CAAC;KACtE;IAED,wEAAwE;IACxE,KAAK,IAAI,GAAC,GAAG,CAAC,EAAE,GAAC,GAAG,yBAAyB,CAAC,MAAM,eAAoB,EAAE,GAAC,EAAE,EAAE;QAC7E,OAAO,CAAC,MAAM,CAAC,sBAAsB,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QAChD,OAAO,CAAC,MAAM,CAAC,uBAAuB,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QACjD,uBAAuB,EAAE,CAAC;QAC1B,qBAAqB,EAAE,CAAC;QACxB,sBAAsB,IAAI,CAAC,CAAC,CAAE,0CAA0C;KACzE;IAED,wEAAwE;IACxE,KAAK,IAAI,GAAC,GAAG,CAAC,EAAE,GAAC,GAAG,yBAAyB,CAAC,MAAM,eAAoB,EAAE,GAAC,EAAE,EAAE;QAC7E,OAAO,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QAC/C,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,qBAAqB,EAAE,CAAC;QACxB,sBAAsB,EAAE,CAAC;KAC1B;IAED,IAAM,cAAc,GAAG,OAAO,oCAAyC,CAAC;IACxE,IAAM,aAAa,GAAG,OAAO,oCAAyC,CAAC;IAEvE,wFAAwF;IACxF,uFAAuF;IACvF,4FAA4F;IAC5F,KAAK,IAAI,GAAC,GAAG,CAAC,EAAE,GAAC,GAAG,eAAe,EAAE,GAAC,EAAE,EAAE;QACxC,IAAM,iBAAiB,GAAG,GAAC,IAAI,yBAAyB,CAAC,MAAM,CAAC;QAChE,IAAM,aAAa,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAAC,GAAG,yBAAyB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAC,CAAC;QACrF,IAAM,QAAQ,GAAG,iBAAiB,CAAC,CAAC,CAAC,yBAAyB,CAAC,aAAa,CAAC,CAAC,CAAC;YAC1C,yBAAyB,CAAC,aAAa,CAAC,CAAC;QAE9E,IAAI,UAAU,SAAA,EAAE,WAAW,SAAA,CAAC;QAC5B,IAAI,iBAAiB,EAAE;YACrB,UAAU,GAAG,sBAAsB;gBAC/B,CAAC,CAAC,yBAAyB,GAAG,aAAa,CAAC,eAAoB,CAAC,CAAC;YACtE,WAAW,GAAG,uBAAuB;gBACjC,CAAC,CAAC,yBAAyB,GAAG,aAAa,CAAC,eAAoB,CAAC,CAAC;SACvE;aAAM;YACL,UAAU;gBACN,qBAAqB,GAAG,CAAC,CAAC,yBAAyB,GAAG,aAAa,CAAC,eAAoB,CAAC,CAAC;YAC9F,WAAW,GAAG,sBAAsB;gBAChC,CAAC,CAAC,yBAAyB,GAAG,aAAa,CAAC,eAAoB,CAAC,CAAC;SACvE;QAED,sEAAsE;QACtE,2EAA2E;QAC3E,8BAA8B;QAC9B,IAAI,qBAAqB,GAAG,iBAAiB,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,aAAa,CAAC;QAC/E,IAAI,eAAe,GAAG,8BAA8B,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAC;QACtF,IAAI,eAAe,KAAK,CAAC,CAAC,EAAE;YAC1B,eAAe,GAAG,qBAAqB,CAAC,MAAM,sBAAwC,CAAC;YACvF,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;SACxE;aAAM;YACL,eAAe,uBAAyC,CAAC;SAC1D;QAED,IAAM,WAAW,GACb,kBAAkB,CAAC,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,cAAc,IAAI,IAAI,CAAC,CAAC;QAErF,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,eAAe,EAAE,UAAU,CAAC,CAAC,CAAC;QAClF,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;QACxC,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;QACrC,qBAAqB,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC;QAE/D,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,WAAW,EAAE,eAAe,EAAE,WAAW,CAAC,CAAC,CAAC;QAClF,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACvC,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;QACpC,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC;KAC/D;IAED,qFAAqF;IACrF,qFAAqF;IACrF,gCAAgC;IAChC,sBAAsB,8BAAkD;QACpE,yBAAyB,GAAG,yBAAyB,CAAC,MAAM,CAAC;IACjE,sBAAsB,6BAAiD;QACnE,yBAAyB,GAAG,yBAAyB,CAAC,MAAM,CAAC;IAEjE,uEAAuE;IACvE,mCAAmC;IACnC,IAAM,UAAU,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,qBAAqB,CAAC;QACpD,CAAC,wBAAwB,CAAC,CAAC,mCAAuC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,OAAO,CAAC,OAAO,8BAAmC,UAAU,CAAC,CAAC;AAChE,CAAC;AAED;;GAEG;AACH,SAAS,gCAAgC,CACrC,OAAuB,EAAE,YAAiB,EAAE,cAAuC;IACrF,IAAM,aAAa,GAAG,OAAO,mCAAwC,CAAC;IACtE,IAAM,wBAAwB,GAAG,OAAO,mCAAwC,CAAC,MAAM,CAAC;IAExF,IAAI,cAAsB,CAAC;IAC3B,IAAM,aAAa,GAAG,iCAAiC,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;IAErF,IAAI,aAAa,KAAK,CAAC,CAAC,EAAE;QACxB,cAAc,GAAG,aAAa,CAAC,MAAM,eAAoC,CAAC;QAC1E,aAAa,CAAC,IAAI,CAAC,YAAY,EAAE,wBAAwB,EAAE,KAAK,EAAE,cAAc,IAAI,IAAI,CAAC,CAAC;KAC3F;SAAM;QACL,IAAM,uBAAuB,GACzB,aAAa,sCAA2D,CAAC;QAC7E,IAAI,aAAa,CAAC,uBAAuB,CAAG,IAAI,CAAC,EAAE;YACjD,0DAA0D;YAC1D,OAAO,CAAC,CAAC,CAAC;SACX;QAED,cAAc,GAAG,aAAa,eAAoC,CAAC;QAEnE,8FAA8F;QAC9F,8FAA8F;QAC9F,sFAAsF;QACtF,IAAM,uBAAuB,GACzB,aAAa,sCAA2D,CAAC;QAC7E,aAAa,CAAC,uBAAuB,CAAC,GAAG,wBAAwB,CAAC;QAElE,wFAAwF;QACxF,WAAW;QACX,IAAM,mBAAmB,GAAG,aAAa,+BAAoD,CAAC;QAC9F,aAAa,CAAC,mBAAmB,CAAC,GAAG,cAAc,IAAI,IAAI,CAAC;KAC7D;IAED,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,SAAS,uBAAuB,CAC5B,OAAuB,EAAE,WAAmB,EAAE,KAAa,EAAE,GAAW;IAC1E,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,gBAAqB,EAAE;QACnD,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,WAAW;YAAE,OAAO,CAAC,CAAC;KACnD;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAC5B,OAAuB,EAAE,YACiD,EAC1E,WACQ,EACR,YAAkB;IACpB,WAAW,GAAG,WAAW,IAAI,IAAI,CAAC;IAElC,IAAM,cAAc,GAAG,6BAA6B,CAAC,OAAO,EAAE,YAAY,IAAI,IAAI,CAAC,CAAC;IACpF,IAAM,OAAO,GAAG,OAAO,yBAA8C,CAAC;IACtE,IAAM,oBAAoB,GAAG,YAAY,YAAY,kBAAkB,CAAC,CAAC;QACrE,IAAI,0BAA0B,CAAC,YAAmB,EAAE,OAAO,gBAAoB,CAAC,CAAC;QACjF,IAAI,CAAC;IACT,IAAM,mBAAmB,GAAG,WAAW,YAAY,kBAAkB,CAAC,CAAC;QACnE,IAAI,0BAA0B,CAAC,WAAkB,EAAE,OAAO,gBAAoB,CAAC,CAAC;QAChF,IAAI,CAAC;IAET,IAAM,YAAY,GAAG,oBAAoB,CAAC,CAAC;QACtC,YAAkE,CAAC,KAAK,CAAC,CAAC;QAC3E,YAAY,CAAC;IACjB,IAAM,WAAW,GAAG,mBAAmB,CAAC,CAAC,CAAC,WAAa,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC;IAC5E,gFAAgF;IAChF,IAAM,qBAAqB,GAAG,oBAAoB,CAAC,OAAO,CAAC,IAAI,YAAY,KAAK,SAAS;QACrF,YAAY,KAAK,OAAO,8CAAmD,CAAC;IAChF,IAAM,qBAAqB,GACvB,WAAW,KAAK,SAAS,IAAI,WAAW,KAAK,OAAO,0BAA+B,CAAC;IACxF,IAAI,qBAAqB,IAAI,qBAAqB;QAAE,OAAO;IAE3D,OAAO,8CAAmD,GAAG,YAAY,CAAC;IAC1E,OAAO,0BAA+B,GAAG,WAAW,CAAC;IAErD,IAAI,UAAU,GAAa,WAAW,CAAC;IACvC,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,IAAI,sBAAsB,GAAG,KAAK,CAAC;IAEnC,IAAM,yBAAyB,GAC3B,oBAAoB,CAAC,CAAC,uCAA2C,CAAC,CAAC,CAAC,CAAC;IACzE,IAAI,uBAAuB,CACnB,OAAO,EAAE,oBAAoB,wCAA4C,EAAE;QACjF,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,wCAA4C,CAAC;QAC3F,sBAAsB,GAAG,IAAI,CAAC;KAC/B;IAED,IAAM,wBAAwB,GAC1B,mBAAmB,CAAC,CAAC,uCAA2C,CAAC,CAAC,CAAC,CAAC;IACxE,IAAI,uBAAuB,CACnB,OAAO,EAAE,mBAAmB,wCAA4C,EAAE;QAChF,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,wCAA4C,CAAC;QAC1F,sBAAsB,GAAG,IAAI,CAAC;KAC/B;IAED,0EAA0E;IAC1E,2BAA2B;IAC3B,IAAI,CAAC,qBAAqB,EAAE;QAC1B,IAAI,OAAO,YAAY,IAAI,QAAQ,EAAE;YACnC,UAAU,GAAG,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACvC,kFAAkF;YAClF,oEAAoE;YACpE,eAAe,GAAG,IAAI,CAAC;SACxB;aAAM;YACL,UAAU,GAAG,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;SACrE;KACF;IAED,IAAM,OAAO,GAAG,CAAC,YAAY,IAAI,SAAS,CAAwB,CAAC;IACnE,IAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;IACxE,IAAM,MAAM,GAAG,WAAW,IAAI,SAAS,CAAC;IAExC,IAAM,iBAAiB,GAAG,UAAU,CAAC,MAAM,CAAC;IAC5C,IAAI,eAAe,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAElD,IAAI,KAAK,GAAG,KAAK,CAAC;IAClB,IAAI,QAAQ,GAAG,eAAe,CAAC;IAE/B,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAM,SAAS,GAAG,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;IAExD,2EAA2E;IAC3E,iFAAiF;IACjF,yEAAyE;IACzE,OAAO,QAAQ,GAAG,OAAO,CAAC,MAAM,IAAI,SAAS,GAAG,SAAS,EAAE;QACzD,IAAM,YAAY,GAAG,SAAS,IAAI,iBAAiB,CAAC;QACpD,IAAM,YAAY,GACd,CAAC,CAAC,YAAY,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAE1F,oEAAoE;QACpE,kDAAkD;QAClD,IAAI,YAAY,EAAE;YAChB,IAAM,iBAAiB,GAAG,YAAY,CAAC,CAAC,CAAC,SAAS,GAAG,iBAAiB,CAAC,CAAC,CAAC,SAAS,CAAC;YACnF,IAAM,OAAO,GACT,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;YACjF,IAAM,QAAQ,GACV,YAAY,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACjF,IAAM,kBAAkB,GACpB,YAAY,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,wBAAwB,CAAC;YAExE,IAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YACxC,IAAI,IAAI,KAAK,OAAO,EAAE;gBACpB,IAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBAC1C,IAAM,IAAI,GAAG,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBAC5C,qBAAqB,CAAC,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,cAAc,CAAC,CAAC;gBAE7E,IAAI,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE;oBAC1C,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;oBACtC,sBAAsB,GAAG,sBAAsB,IAAI,CAAC,CAAC,kBAAkB,CAAC;oBAExE,IAAM,YAAY,GAAG,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;oBAEpD,wBAAwB;oBACxB,sEAAsE;oBACtE,uEAAuE;oBACvE,0EAA0E;oBAC1E,sEAAsE;oBACtE,oDAAoD;oBACpD,IAAI,KAAK,IAAI,IAAI,IAAI,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE;wBAClE,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;wBAClC,KAAK,GAAG,IAAI,CAAC;qBACd;iBACF;aACF;iBAAM;gBACL,IAAM,YAAY,GAAG,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;gBACzE,IAAI,YAAY,GAAG,CAAC,EAAE;oBACpB,yDAAyD;oBACzD,IAAM,cAAc,GAAG,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;oBACvD,IAAM,aAAa,GAAG,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;oBACzD,uBAAuB,CAAC,OAAO,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;oBACzD,IAAI,eAAe,CAAC,aAAa,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE;wBAC5D,IAAM,YAAY,GAAG,eAAe,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;wBAC7D,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;wBAEtC,qEAAqE;wBACrE,IAAI,cAAc,IAAI,IAAI,IAAI,eAAe,CAAC,aAAa,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE;4BACpF,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;4BAClC,sBAAsB,GAAG,sBAAsB,IAAI,CAAC,CAAC,kBAAkB,CAAC;4BACxE,KAAK,GAAG,IAAI,CAAC;yBACd;qBACF;iBACF;qBAAM;oBACL,4DAA4D;oBAC5D,IAAM,OAAO,GAAG,kBAAkB,CAC9B,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC;oBAChF,sBAAsB,GAAG,sBAAsB,IAAI,CAAC,CAAC,kBAAkB,CAAC;oBACxE,sBAAsB,CAClB,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAC3E,kBAAkB,CAAC,CAAC;oBACxB,KAAK,GAAG,IAAI,CAAC;iBACd;aACF;SACF;QAED,QAAQ,gBAAqB,CAAC;QAC9B,SAAS,EAAE,CAAC;KACb;IAED,iEAAiE;IACjE,+DAA+D;IAC/D,sEAAsE;IACtE,OAAO,QAAQ,GAAG,OAAO,CAAC,MAAM,EAAE;QAChC,IAAM,IAAI,GAAG,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC5C,IAAM,YAAY,GAAG,CAAC,IAAI,gBAAqB,CAAC,kBAAuB,CAAC;QACxE,IAAM,YAAY,GACd,CAAC,CAAC,YAAY,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC1F,IAAI,YAAY,EAAE;YAChB,IAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YAC1C,IAAM,aAAa,GAAG,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;YACvD,IAAI,aAAa,EAAE;gBACjB,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;gBAClC,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;gBAElC,qEAAqE;gBACrE,wEAAwE;gBACxE,2CAA2C;gBAC3C,IAAM,kBAAkB,GACpB,YAAY,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,wBAAwB,CAAC;gBACxE,qBAAqB,CAAC,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,cAAc,CAAC,CAAC;gBAC7E,KAAK,GAAG,IAAI,CAAC;aACd;SACF;QACD,QAAQ,gBAAqB,CAAC;KAC/B;IAED,qEAAqE;IACrE,kEAAkE;IAClE,oDAAoD;IACpD,IAAM,SAAS,GAAG,iBAAiB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IAC7D,OAAO,SAAS,GAAG,SAAS,EAAE;QAC5B,IAAM,YAAY,GAAG,SAAS,IAAI,iBAAiB,CAAC;QACpD,IAAM,YAAY,GACd,CAAC,CAAC,YAAY,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAC1F,IAAI,YAAY,EAAE;YAChB,IAAM,iBAAiB,GAAG,YAAY,CAAC,CAAC,CAAC,SAAS,GAAG,iBAAiB,CAAC,CAAC,CAAC,SAAS,CAAC;YACnF,IAAM,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;YAC1F,IAAM,KAAK,GACP,YAAY,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3E,IAAM,IAAI,GAAG,kBAAkB,CAAC,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS,CAAC,gBAAqB,CAAC;YAC7F,IAAM,kBAAkB,GACpB,YAAY,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,wBAAwB,CAAC;YACxE,IAAM,UAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;YAChC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;YACnC,qBAAqB,CAAC,OAAO,EAAE,UAAQ,EAAE,kBAAkB,EAAE,cAAc,CAAC,CAAC;YAC7E,KAAK,GAAG,IAAI,CAAC;SACd;QACD,SAAS,EAAE,CAAC;KACb;IAED,IAAI,KAAK,EAAE;QACT,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC/B,iBAAiB,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;KAClD;IAED,IAAI,sBAAsB,EAAE;QAC1B,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;KACvC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuB,EAAE,MAAc,EAAE,WAAkD,EAC3F,YAAkB;IACpB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuB,EAAE,MAAc,EACvC,KAAwE,EACxE,YAAkB;IACpB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;AACzE,CAAC;AAED,SAAS,yBAAyB,CAC9B,OAAuB,EAAE,MAAc,EACvC,KAAwE,EAAE,YAAqB,EAC/F,YAAiB;IACnB,IAAM,cAAc,GAAG,6BAA6B,CAAC,OAAO,EAAE,YAAY,IAAI,IAAI,CAAC,CAAC;IACpF,IAAM,WAAW,GAAG,uBAAuB,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3F,IAAM,SAAS,GAAG,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACjD,IAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACnD,IAAM,aAAa,GAAG,0BAA0B,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACvE,IAAM,KAAK,GAAwB,CAAC,KAAK,YAAY,kBAAkB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IAE/F,IAAI,eAAe,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,CAAC;QAC3C,gBAAgB,CAAC,SAAS,EAAE,KAAK,EAAE,aAAa,EAAE,cAAc,CAAC,EAAE;QACrE,IAAM,cAAY,GAAG,CAAC,QAAQ,gBAAqB,CAAC,kBAAuB,CAAC;QAC5E,IAAM,OAAO,GAAG,OAAO,yBAA8C,CAAC;QACtE,IAAM,aAAa,GAAG,KAAK,YAAY,kBAAkB,CAAC,CAAC;YACvD,IAAI,0BAA0B,CAC1B,KAAY,EAAE,OAAO,EAAE,cAAY,CAAC,CAAC,eAAmB,CAAC,cAAkB,CAAC,CAAC,CAAC;YAClF,IAAI,CAAC;QACT,IAAM,OAAK,GAAG,CAAC,aAAa,CAAC,CAAC,CAAE,KAAiC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAC7D,CAAC;QACnB,IAAM,eAAe,GAAG,qBAAqB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAEpE,IAAI,sBAAsB,GAAG,KAAK,CAAC;QACnC,IAAI,kBAAkB,GAAG,aAAa,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7D,IAAI,uBAAuB,CAAC,OAAO,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE;YACpE,IAAM,QAAQ,GAAG,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;YAC3E,kBAAkB,GAAG,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YAClD,sBAAsB,GAAG,IAAI,CAAC;SAC/B;QAED,IAAI,sBAAsB,IAAI,aAAa,KAAK,cAAc,EAAE;YAC9D,qBAAqB,CAAC,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,cAAc,CAAC,CAAC;SACjF;QAED,IAAI,aAAa,KAAK,cAAc,EAAE;YACpC,IAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YAC3C,IAAM,SAAS,GAAG,iBAAiB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YAC7D,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;SACtF;QAED,wEAAwE;QACxE,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,OAAK,CAAC,CAAC;QACtC,IAAM,aAAa,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAEtD,oFAAoF;QACpF,IAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QACvD,IAAI,CAAC,aAAa,IAAI,eAAe,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAK,CAAC,EAAE;YACrE,IAAI,UAAU,GAAG,KAAK,CAAC;YACvB,IAAI,WAAW,GAAG,IAAI,CAAC;YAEvB,0EAA0E;YAC1E,IAAI,CAAC,WAAW,CAAC,OAAK,EAAE,cAAY,CAAC,IAAI,WAAW,CAAC,aAAa,EAAE,cAAY,CAAC,EAAE;gBACjF,UAAU,GAAG,IAAI,CAAC;gBAClB,WAAW,GAAG,KAAK,CAAC;aACrB;YAED,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;YAC7C,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;YAC5C,iBAAiB,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;YACjD,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;SAChC;QAED,IAAI,sBAAsB,EAAE;YAC1B,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;SACvC;KACF;AACH,CAAC;AAGD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,aAAa,CACzB,OAAuB,EAAE,QAAmB,EAAE,UAA+B,EAC7E,aAAsB,EAAE,YAAkC,EAAE,WAAiC,EAC7F,YAAkB;IACpB,IAAI,kBAAkB,GAAG,CAAC,CAAC;IAC3B,IAAM,oBAAoB,GAAG,6BAA6B,CAAC,OAAO,EAAE,YAAY,IAAI,IAAI,CAAC,CAAC;IAE1F,IAAI,cAAc,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,CAAC,EAAE;QAC9E,IAAM,mBAAmB,GACrB,OAAO,4BAAiC,8BAAmC,CAAC;QAChF,IAAM,MAAM,GAAG,OAAO,yBAAgC,CAAC;QACvD,IAAM,eAAe,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACpD,IAAM,iBAAiB,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAExD,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,KAAK,IAAI,CAAC,oCAAyC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAClE,CAAC,gBAAqB,EAAE;YAC3B,wEAAwE;YACxE,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE;gBACvB,IAAM,IAAI,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;gBACrC,IAAM,cAAc,GAAG,0BAA0B,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;gBAC9D,IAAI,oBAAoB,KAAK,cAAc,EAAE;oBAC3C,UAAU,GAAG,IAAI,CAAC;oBAClB,SAAS;iBACV;gBAED,IAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;gBACjC,IAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;gBACnC,IAAM,cAAc,GAChB,CAAC,IAAI,mBAAwB,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBACvF,IAAM,aAAa,GAAG,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;gBACnD,IAAM,YAAY,GAAG,IAAI,gBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;gBAC9D,IAAM,gBAAgB,GAAG,CAAC,GAAG,eAAe,CAAC;gBAC7C,IAAM,gBAAgB,GAAG,CAAC,YAAY,IAAI,CAAC,iBAAiB,CAAC;gBAE7D,IAAI,YAAY,GAAwB,KAAK,CAAC;gBAE9C,uEAAuE;gBACvE,4DAA4D;gBAC5D,2DAA2D;gBAC3D,IAAI,gBAAgB,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,YAAY,CAAC,EAAE;oBAChE,yDAAyD;oBACzD,IAAM,UAAU,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;oBAC/C,YAAY,GAAG,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;iBAC9C;gBAED,yEAAyE;gBACzE,qDAAqD;gBACrD,+DAA+D;gBAC/D,sEAAsE;gBACtE,wEAAwE;gBACxE,6EAA6E;gBAC7E,+EAA+E;gBAC/E,+EAA+E;gBAC/E,IAAI,CAAC,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,YAAY,CAAC,IAAI,gBAAgB,EAAE;oBACjF,YAAY,GAAG,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;iBAC/C;gBAED,0EAA0E;gBAC1E,wEAAwE;gBACxE,yEAAyE;gBACzE,qBAAqB;gBACrB,IAAM,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;gBACzD,IAAI,YAAY,EAAE;oBAChB,IAAI,YAAY,EAAE;wBAChB,QAAQ,CACJ,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,CAAC,CAAC;qBACvF;yBAAM;wBACL,QAAQ,CACJ,MAAM,EAAE,IAAI,EAAE,YAA6B,EAAE,QAAQ,EAAE,cAAc,EAAE,WAAW,EAClF,aAAa,CAAC,CAAC;qBACpB;iBACF;gBAED,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;aAC7B;SACF;QAED,IAAI,mBAAmB,EAAE;YACvB,IAAM,WAAW,GACb,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAyB,CAAC;YACvF,IAAM,aAAa,GAAG,gBAAgB,CAAC,OAAO,CAAG,CAAC;YAClD,IAAM,iBAAiB,GAAG,aAAa,gCAAoC,CAAC;YAC5E,KAAK,IAAI,CAAC,sCAA0C,EAAE,CAAC,GAAG,iBAAiB,EACtE,CAAC,4CAAgD,EAAE;gBACtD,IAAM,OAAO,GAAG,aAAa,CAAC,CAAC,CAA0C,CAAC;gBAC1E,IAAM,oBAAoB,GAAG,CAAC,+BAAmC,CAAC;gBAClE,IAAM,SAAS,GAAG,aAAa,CAAC,oBAAoB,CAAkB,CAAC;gBACvE,IAAI,OAAO,EAAE;oBACX,IAAM,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;oBAC7D,IAAI,MAAM,KAAK,SAAS,EAAE;wBACxB,IAAI,MAAM,IAAI,IAAI,EAAE;4BAClB,IAAM,SAAS,GAAG,iBAAiB,CAC/B,aAAa,EAAE,WAAW,EAAE,MAAqB,EAAE,MAAM,EAAE,oBAAoB,CAAC,CAAC;4BACrF,SAAS,IAAI,kBAAkB,EAAE,CAAC;yBACnC;wBACD,IAAI,SAAS,EAAE;4BACb,SAAS,CAAC,OAAO,EAAE,CAAC;yBACrB;qBACF;iBACF;qBAAM,IAAI,SAAS,EAAE;oBACpB,oFAAoF;oBACpF,SAAS;oBACT,SAAS,CAAC,OAAO,EAAE,CAAC;iBACrB;aACF;YACD,sBAAsB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;SACxC;QAED,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,EAAE,KAAK,CAAC,CAAC;QACxD,eAAe,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;KACtC;IAED,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CACpB,MAAW,EAAE,IAAY,EAAE,KAAoB,EAAE,QAAmB,EACpE,SAAiC,EAAE,KAA2B,EAC9D,aAAqD;IACvD,KAAK,GAAG,SAAS,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC5D,IAAI,KAAK,IAAI,aAAa,EAAE;QAC1B,IAAI,KAAK,EAAE;YACT,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SAC7B;QACD,IAAI,aAAa,EAAE;YACjB,aAAa,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SACrC;KACF;SAAM,IAAI,KAAK,EAAE;QAChB,KAAK,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAE,oEAAoE;QACpE,oBAAoB;QAC/C,SAAS,IAAI,SAAS,CAAC,gBAAgB,EAAE,CAAC;QAC1C,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC5B,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC,CAAC;YACtE,MAAM,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;KAC9C;SAAM;QACL,SAAS,IAAI,SAAS,CAAC,mBAAmB,EAAE,CAAC;QAC7C,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC5B,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC,CAAC;YAClE,MAAM,CAAC,OAAO,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;KAC1C;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,QAAQ,CACb,MAAW,EAAE,SAAiB,EAAE,GAAY,EAAE,QAAmB,EAAE,KAA2B,EAC9F,aAAqD;IACvD,IAAI,KAAK,IAAI,aAAa,EAAE;QAC1B,IAAI,KAAK,EAAE;YACT,KAAK,CAAC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;SAChC;QACD,IAAI,aAAa,EAAE;YACjB,aAAa,CAAC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;SACxC;KACF;SAAM,IAAI,GAAG,EAAE;QACd,SAAS,IAAI,SAAS,CAAC,gBAAgB,EAAE,CAAC;QAC1C,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;YACtC,MAAM,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;KACrE;SAAM;QACL,SAAS,IAAI,SAAS,CAAC,mBAAmB,EAAE,CAAC;QAC7C,oBAAoB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;KACxE;AACH,CAAC;AAED,SAAS,eAAe,CAAC,OAAuB,EAAE,KAAa,EAAE,WAAoB;IACnF,IAAI,WAAW,EAAE;QACd,OAAO,CAAC,KAAK,CAAY,oBAAyB,CAAC;KACrD;SAAM;QACJ,OAAO,CAAC,KAAK,CAAY,IAAI,iBAAsB,CAAC;KACtD;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,OAAuB,EAAE,KAAa,EAAE,UAAmB;IAC3E,IAAM,aAAa,GACf,KAAK,qCAA0C,CAAC,CAAC,CAAC,CAAC,KAAK,sBAA2B,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACjG,IAAI,UAAU,EAAE;QACb,OAAO,CAAC,aAAa,CAAY,iBAAsB,CAAC;KAC1D;SAAM;QACJ,OAAO,CAAC,aAAa,CAAY,IAAI,cAAmB,CAAC;KAC3D;AACH,CAAC;AAED,SAAS,OAAO,CAAC,OAAuB,EAAE,KAAa;IACrD,IAAM,aAAa,GACf,KAAK,qCAA0C,CAAC,CAAC,CAAC,CAAC,KAAK,sBAA2B,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACjG,OAAO,CAAE,OAAO,CAAC,aAAa,CAAY,gBAAqB,CAAC,iBAAsB,CAAC;AACzF,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,OAAuB,EAAE,KAAa;IACtE,IAAM,aAAa,GACf,KAAK,qCAA0C,CAAC,CAAC,CAAC,CAAC,KAAK,sBAA2B,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACjG,OAAO,CAAE,OAAO,CAAC,aAAa,CAAY,gBAAqB,CAAC,iBAAsB,CAAC;AACzF,CAAC;AAED,SAAS,aAAa,CAAC,OAAuB,EAAE,KAAa;IAC3D,IAAM,aAAa,GACf,KAAK,qCAA0C,CAAC,CAAC,CAAC,CAAC,KAAK,sBAA2B,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACjG,OAAO,CAAE,OAAO,CAAC,aAAa,CAAY,mBAAwB,CAAC,oBAAyB,CAAC;AAC/F,CAAC;AAED,SAAS,QAAQ,CAAC,UAAkB,EAAE,WAAmB,EAAE,YAAoB;IAC7E,OAAO,CAAC,UAAU,mBAAuB,CAAC,GAAG,CAAC,WAAW,wBAA6B,CAAC;QACnF,CAAC,YAAY,IAAI,CAAC,4CAAqD,CAAC,CAAC,CAAC;AAChF,CAAC;AAED,SAAS,eAAe,CAAC,OAAuB,EAAE,IAAY;IAC5D,IAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IACpC,IAAM,iBAAiB,GAAG,IAAI,gBAAqB,CAAC;IACpD,IAAM,aAAa,GAAG,iBAAiB,CAAC,CAAC,CAAC,OAAO,oCAAyC,CAAC,CAAC;QAClD,OAAO,oCAAyC,CAAC;IAC3F,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED,SAAS,eAAe,CAAC,IAAY;IACnC,OAAO,CAAC,IAAI,wBAA6B,CAAC,sBAAuB,CAAC;AACpE,CAAC;AAED,SAAS,qBAAqB,CAAC,IAAY;IACzC,IAAM,KAAK,GACP,CAAC,IAAI,IAAI,CAAC,4CAAqD,CAAC,CAAC,sBAAuB,CAAC;IAC7F,OAAO,KAAK,qCAA0C,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtE,CAAC;AAED,SAAS,kBAAkB,CAAC,OAAuB;IACjD,OAAO,qBAAqB,CAAC,OAAO,4BAAiC,CAAW,CAAC;AACnF,CAAC;AAED,SAAS,OAAO,CAAC,OAAuB,EAAE,KAAa,EAAE,IAAY;IACnE,OAAO,CAAC,KAAK,yBAA8B,CAAC,GAAG,IAAI,CAAC;AACtD,CAAC;AAED,SAAS,QAAQ,CAAC,OAAuB,EAAE,KAAa,EAAE,KAA8B;IACtF,OAAO,CAAC,KAAK,sBAA2B,CAAC,GAAG,KAAK,CAAC;AACpD,CAAC;AAED,SAAS,uBAAuB,CAC5B,OAAuB,EAAE,OAA8C,EAAE,KAAa;IACxF,IAAM,aAAa,GAAG,OAAO,uBAA8B,CAAC;IAC5D,IAAI,OAAO,EAAE;QACX,IAAI,CAAC,aAAa,IAAI,KAAK,KAAK,CAAC,EAAE;YACjC,OAAO,IAAI,CAAC;SACb;KACF;SAAM,IAAI,CAAC,aAAa,EAAE;QACzB,OAAO,KAAK,CAAC;KACd;IACD,OAAO,aAAa,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC;AAC1C,CAAC;AAED,SAAS,gBAAgB,CACrB,OAAuB,EAAE,OAA8C,EACvE,cAAsB;IACxB,IAAI,aAAa,GAAG,OAAO,uBAA4B,IAAI,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACvF,IAAI,cAAc,GAAG,CAAC,EAAE;QACtB,aAAa,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC;KACzC;SAAM;QACL,cAAc,GAAG,aAAa,gCAAoC,CAAC;QACnE,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QACvD,aAAa,gCAAoC;oDACD,CAAC;KAClD;IACD,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,cAAsB,EAAE,WAAmB;IAChF,OAAO,CAAC,WAAW,yBAAoD,CAAC,GAAG,cAAc,CAAC;AAC5F,CAAC;AAED,SAAS,qBAAqB,CAC1B,OAAuB,EAAE,KAAa,EAAE,kBAA0B,EAAE,cAAsB;IAC5F,IAAM,KAAK,GAAG,sBAAsB,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;IACzE,OAAO,CAAC,KAAK,mCAAwC,CAAC,GAAG,KAAK,CAAC;AACjE,CAAC;AAED,SAAS,qBAAqB,CAAC,OAAuB,EAAE,KAAa;IACnE,IAAM,IAAI,GAAG,OAAO,CAAC,KAAK,mCAAwC,CAAW,CAAC;IAC9E,IAAM,kBAAkB,GAAG,CAAC,IAAI,yBAAoD,CAAC;2BACtC,CAAC;IAChD,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED,SAAS,gBAAgB,CAAC,OAAuB,EAAE,KAAa;IAE9D,IAAM,kBAAkB,GAAG,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACjE,IAAI,kBAAkB,EAAE;QACtB,IAAM,aAAa,GAAG,OAAO,uBAA4B,CAAC;QAC1D,IAAI,aAAa,EAAE;YACjB,OAAO,aAAa,CAAC,kBAAkB,CAA0C,CAAC;SACnF;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,OAAO,CAAC,OAAuB,EAAE,KAAa,EAAE,IAAY;IACnE,IAAM,aAAa,GACf,KAAK,+BAAoC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,sBAA2B,CAAC,CAAC;IAC3F,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;AAChC,CAAC;AAED,SAAS,WAAW,CAAC,OAAuB,EAAE,KAAa;IACzD,IAAM,aAAa,GACf,KAAK,+BAAoC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,sBAA2B,CAAC,CAAC;IAC3F,OAAO,OAAO,CAAC,aAAa,CAAW,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,OAAuB,EAAE,KAAa;IAC7D,OAAO,OAAO,CAAC,KAAK,sBAA2B,CAA4B,CAAC;AAC9E,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,OAAuB,EAAE,KAAa;IAC5D,OAAO,OAAO,CAAC,KAAK,yBAA8B,CAAW,CAAC;AAChE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,OAAuB;IACpD,OAAO,OAAO,CAAC,OAAO,6BAAkC,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAAuB;IAC1D,OAAO,OAAO,4BAAiC,oCAAwC,CAAC;AAC1F,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,OAAuB,EAAE,UAAmB;IAC1E,QAAQ,CAAC,OAAO,8BAAmC,UAAU,CAAC,CAAC;AACjE,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,OAAuB,EAAE,UAAmB;IACjF,IAAI,UAAU,EAAE;QACb,OAAO,4BAA4C,+BAAoC,CAAC;KAC1F;SAAM;QACJ,OAAO,4BAA4C,IAAI,4BAAiC,CAAC;KAC3F;AACH,CAAC;AAED,SAAS,uBAAuB,CAC5B,OAAuB,EAAE,IAAY,EAAE,UAAmB;IAC5D,KAAK,IAAI,CAAC,GAAG,CAAC,UAAU,IAAI,CAAC,CAAC,yBAA8B,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAC3E,CAAC,gBAAqB,EAAE;QAC3B,IAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,QAAQ,IAAI,IAAI,EAAE;YACpB,OAAO,CAAC,yBAA8B,CAAC;SACxC;KACF;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED,SAAS,uBAAuB,CAAC,OAAuB,EAAE,MAAc,EAAE,MAAc;IACtF,IAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC3C,IAAM,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACzC,IAAM,OAAO,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC7C,IAAM,qBAAqB,GAAG,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAErE,IAAI,KAAK,GAAG,OAAO,CAAC;IACpB,IAAI,KAAK,GAAG,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAEzC,IAAM,YAAY,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,IAAI,YAAY,IAAI,CAAC,EAAE;QACrB,IAAM,KAAK,GAAG,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QACjD,IAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;KACnE;IAED,IAAM,YAAY,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,IAAI,YAAY,IAAI,CAAC,EAAE;QACrB,IAAM,KAAK,GAAG,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QACjD,IAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;KACnE;IAED,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IACvD,IAAM,YAAY,GAAG,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5D,IAAM,eAAe,GAAG,CAAC,CAAC;IAC1B,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,CAAC,CAAC;IAEtE,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IACpC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,qBAAqB,EAAE,eAAe,CAAC,CAAC;AACjF,CAAC;AAED,SAAS,yBAAyB,CAAC,OAAuB,EAAE,kBAA0B;IACpF,KAAK,IAAI,CAAC,GAAG,kBAAkB,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,gBAAqB,EAAE;QAC3E,IAAM,SAAS,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QAC1C,IAAM,WAAW,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;QACrD,IAAI,WAAW,GAAG,CAAC,EAAE;YACnB,IAAM,UAAU,GAAG,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YACrD,IAAM,qBAAqB,GAAG,eAAe,CAAC,UAAU,CAAC,CAAC;YAC1D,IAAM,SAAS,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,eAAoB,CAAC,aAAkB,CAAC;gBACtF,CAAC,iBAAiB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,eAAoB,CAAC,aAAkB,CAAC;gBAClF,CAAC,aAAa,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,kBAAuB,CAAC,aAAkB,CAAC,CAAC;YACtF,IAAM,WAAW,GAAG,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAC,CAAC,CAAC;YAClE,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;SAC5C;KACF;AACH,CAAC;AAED,SAAS,sBAAsB,CAC3B,OAAuB,EAAE,KAAa,EAAE,UAAmB,EAAE,IAAY,EAAE,IAAY,EACvF,KAAuB,EAAE,cAAsB,EAAE,WAAmB;IACtE,IAAM,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC;IAEvC,6CAA6C;IAC7C,OAAO,CAAC,MAAM,CACV,KAAK,EAAE,CAAC,EAAE,IAAI,gBAAqB,GAAG,CAAC,UAAU,CAAC,CAAC,eAAoB,CAAC,aAAkB,CAAC,EAC3F,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IACpB,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;IAEnE,IAAI,OAAO,EAAE;QACX,+DAA+D;QAC/D,4DAA4D;QAC5D,kDAAkD;QAClD,yBAAyB,CAAC,OAAO,EAAE,KAAK,eAAoB,CAAC,CAAC;KAC/D;AACH,CAAC;AAED,SAAS,WAAW,CAAC,KAA8B,EAAE,YAAsB;IACzE,IAAI,YAAY,EAAE;QAChB,OAAO,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;KAC7B;IACD,OAAO,KAAK,KAAK,IAAI,CAAC;AACxB,CAAC;AAED,SAAS,kBAAkB,CACvB,OAAuB,EAAE,IAAY,EAAE,iBAA0B,EACjE,SAAkC;IACpC,IAAI,IAAI,GAAG,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,kBAAuB,CAAC,aAAkB,CAAC;IAEtF,IAAI,YAAoB,CAAC;IACzB,IAAI,iBAAiB,EAAE;QACrB,IAAI,iBAAsB,CAAC;QAC3B,YAAY;YACR,8BAA8B,CAAC,OAAO,oCAAyC,EAAE,IAAI,CAAC,CAAC;KAC5F;SAAM;QACL,YAAY;YACR,8BAA8B,CAAC,OAAO,oCAAyC,EAAE,IAAI,CAAC,CAAC;KAC5F;IAED,YAAY,GAAG,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,sBAAwC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7F,OAAO,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC;AACzC,CAAC;AAED,SAAS,eAAe,CACpB,IAAY,EAAE,CAA0B,EAAE,CAA0B;IACtE,IAAM,YAAY,GAAG,IAAI,gBAAqB,CAAC;IAC/C,IAAM,SAAS,GAAG,CAAC,IAAI,CAAC,CAAC;IACzB,IAAM,aAAa,GAAG,IAAI,mBAAwB,CAAC;IACnD,4DAA4D;IAC5D,mEAAmE;IACnE,sDAAsD;IACtD,IAAI,CAAC,YAAY,IAAI,SAAS,IAAI,aAAa,EAAE;QAC/C,4DAA4D;QAC5D,OAAQ,CAAY,CAAC,QAAQ,EAAE,KAAM,CAAY,CAAC,QAAQ,EAAE,CAAC;KAC9D;IAED,gEAAgE;IAChE,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC;AAED;IAKE,oCAAY,OAAsB,EAAU,QAAqB,EAAU,KAAkB;QAAjD,aAAQ,GAAR,QAAQ,CAAa;QAAU,UAAK,GAAL,KAAK,CAAa;QAJrF,YAAO,GAAmC,EAAE,CAAC;QAC7C,WAAM,GAAG,KAAK,CAAC;QAIrB,IAAI,CAAC,QAAQ,GAAG,OAAc,CAAC;IACjC,CAAC;IAED,6CAAQ,GAAR,UAAS,IAAY,EAAE,KAAU;QAC/B,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,KAAK,EAAE;YAChC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;YAC3B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;SACpB;IACH,CAAC;IAED,gDAAW,GAAX,UAAY,aAA0B,EAAE,aAAsB;QAC5D,qEAAqE;QACrE,mEAAmE;QACnE,yDAAyD;QACzD,IAAI,IAAI,CAAC,MAAM,EAAE;YACf,IAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAC3B,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAS,EAAE,aAAa,EAAE,aAAa,IAAI,IAAI,CAAC,CAAC;YACrF,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;YAClB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,OAAO,MAAM,CAAC;SACf;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IACH,iCAAC;AAAD,CAAC,AA9BD,IA8BC;;AAiCD,MAAM,UAAU,qBAAqB,CAAC,MAA+B,EAAE,KAAc;IACnF,IAAI,IAAI,EAAE,IAAI,GAAG,mBAAmB,CAAC;IACrC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,IAAI,KAAK,EAAE;YACT,IAAI,IAAI,SAAS,GAAG,KAAK,CAAC;SAC3B;aAAM;YACL,IAAI,IAAI,eAAe,CAAC;SACzB;QACD,KAAK,GAAG,KAAK,8BAAmC,CAAC;QACjD,IAAI,GAAG,MAAM,CAAC,KAAK,CAAW,CAAC;KAChC;SAAM;QACL,IAAI,GAAG,MAAM,CAAC;QACd,IAAI,IAAI,SAAS,GAAG,IAAI,CAAC;KAC1B;IACD,IAAM,YAAY,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IACjD,IAAM,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IAC1C,OAAO;QACL,IAAI,MAAA;QACJ,WAAW,aAAA;QACX,YAAY,cAAA;QACZ,KAAK,EAAE,IAAI;QACX,KAAK,EAAE;YACL,KAAK,EAAE,IAAI,gBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;YAC/C,KAAK,EAAE,IAAI,gBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;YAC/C,QAAQ,EAAE,IAAI,mBAAwB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;YACrD,mBAAmB,EAAE,IAAI,8BAAmC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;YAC3E,wBAAwB,EAAE,IAAI,oCAAwC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;YACrF,uBAAuB,EAAE,IAAI,mCAAuC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;SACpF;KACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,OAAuB,EAAE,KAAa;IAC/E,IAAM,KAAK,GAAG,OAAO,CAAC,KAAK,mCAAwC,CAAW,CAAC;IAC/E,OAAO,KAAK,sBAA8C,CAAC;AAC7D,CAAC;AAED,SAAS,6BAA6B,CAAC,OAAuB,EAAE,SAAc;IAC5E,IAAM,KAAK,GACP,iCAAiC,CAAC,OAAO,mCAAwC,EAAE,SAAS,CAAC,CAAC;IAClG,SAAS;QACL,cAAc,CACV,KAAK,EAAE,CAAC,CAAC,EACT,4BAA0B,SAAS,kEAAgE,CAAC,CAAC;IAC7G,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,eAAoC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,oDAAoD;AACtD,CAAC;AAED,SAAS,iCAAiC,CACtC,UAAmC,EAAE,SAAa;IACpD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,gBAAqC,EAAE;QAC7E,IAAI,UAAU,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE;YAC/B,OAAO,CAAC,CAAC;SACV;KACF;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED,SAAS,8BAA8B,CAAC,SAA+B,EAAE,GAAW;IAClF,KAAK,IAAI,CAAC,gCAAkD,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAC7E,CAAC,gBAAkC,EAAE;QACxC,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,GAAG;YAAE,OAAO,CAAC,CAAC;KACpC;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,CAAa,EAAE,CAAa;IAC9D,IAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAM,KAAK,GAAyB,EAAE,CAAC;IACvC,iBAAiB,CAAC,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7D,iBAAiB,CAAC,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/D,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CACxB,UAAA,IAAI,IAAM,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEpF,IAAI,KAAK,CAAC,MAAM,EAAE;QAChB,GAAG,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC/B,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3B,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3B,GAAG,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;QACvD,KAAK,CAAC,OAAO,CAAC,UAAA,MAAM;YACZ,IAAA,8BAA2B,EAA1B,YAAI,EAAE,YAAI,EAAE,YAAc,CAAC;YAClC,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;YAC3B,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;KACJ;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,iBAAiB,CAAC,MAAa,EAAE,IAAY,EAAE,IAAY,EAAE,CAAM,EAAE,CAAM;IAClF,IAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;IACrB,IAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;IACrB,IAAI,IAAI,KAAK,IAAI,EAAE;QACjB,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;KACjC;AACH,CAAC;AAED,SAAS,uBAAuB,CAC5B,OAAuB,EAAE,cAAsB,EAAE,MAAc,EAAE,YAAqB;IACxF,IAAM,6BAA6B,GAC/B,OAAO,mCAAwC,CACvC,CAAC,cAAc,eAAoC,CAAC;2CACI,CAAW,CAAC;IAChF,IAAM,OAAO,GAAG,OAAO,mCAAwC,CAAC;IAChE,IAAM,cAAc,GAAG,6BAA6B;kCACF;QAC9C,CAAC,YAAY,CAAC,CAAC;YACV,OAAO,CACF,6BAA6B,8BAAkD,CAAC,CAAC,CAAC;YACvF,CAAC,CAAC;QACP,MAAM,CAAC;IACX,OAAO,OAAO,CAAC,cAAc,CAAC,CAAC;AACjC,CAAC;AAED,SAAS,iBAAiB,CAAC,OAAuB,EAAE,cAAsB;IACxE,IAAM,IAAI,GAAG,OAAO,mCAAwC,CAAC;IAC7D,IAAM,KAAK,GAAG,IAAI,CACC,cAAc,eAAoC;oCACD,CAAC;QACjE,IAAI,8BAAmD,IAAI,IAAI,CAAC;IACpE,OAAO,KAA+B,CAAC;AACzC,CAAC;AAED,SAAS,gBAAgB,CAAC,OAAuB,EAAE,cAAsB;IACvE,IAAM,IAAI,GAAG,OAAO,mCAAwC,CAAC;IAC7D,OAAO,IAAI,CACN,cAAc,eAAoC;+BACN,CAAY,CAAC;AAChE,CAAC;AAED,SAAS,iBAAiB,CACtB,OAAuB,EAAE,cAAsB,EAAE,QAAiB;IACpE,IAAM,IAAI,GAAG,OAAO,mCAAwC,CAAC;IAC7D,IAAI,CACC,cAAc,eAAoC;+BACN,CAAC,GAAG,QAAQ,CAAC;AAChE,CAAC;AAED,SAAS,gBAAgB,CACrB,YAAqC,EAAE,QAAiC,EACxE,qBAA6B,EAAE,iBAAyB;IAC1D,0EAA0E;IAC1E,0EAA0E;IAC1E,6EAA6E;IAC7E,gFAAgF;IAChF,iFAAiF;IACjF,kFAAkF;IAClF,gFAAgF;IAChF,oFAAoF;IACpF,gEAAgE;IAChE,IAAI,YAAY,EAAE;QAChB,IAAI,QAAQ,EAAE;YACZ,qEAAqE;YACrE,gCAAgC;YAChC,OAAO,iBAAiB,IAAI,qBAAqB,CAAC;SACnD;aAAM;YACL,iEAAiE;YACjE,+DAA+D;YAC/D,6DAA6D;YAC7D,yCAAyC;YACzC,OAAO,qBAAqB,KAAK,iBAAiB,CAAC;SACpD;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAuB;IAC9D,IAAI,SAAS,GAAG,OAAO,8CAA6D,CAAC;IACrF,IAAI,SAAS,IAAI,IAAI,EAAE;QACrB,SAAS,GAAG,EAAE,CAAC;QACf,IAAM,kBAAkB,GAAG,OAAO,oCAAyC,CAAC;QAC5E,KAAK,IAAI,CAAC,gCAAkD,EAAE,CAAC,GAAG,kBAAkB,CAAC,MAAM,EACtF,CAAC,gBAAkC,EAAE;YACxC,IAAM,SAAS,GAAG,kBAAkB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC5C,IAAI,SAAS,EAAE;gBACb,SAAS,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC;aACpE;SACF;QACD,OAAO,8CAAmD,GAAG,SAAS,CAAC;KACxE;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {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"]}