@angular/core 9.0.0-rc.6 → 9.0.0

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

@@ -3,27 +3,30 @@
  * Generated from: packages/core/src/render3/instructions/styling.ts
  * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
-import { throwErrorIfNoChangesMode } from '../errors';
-import { setInputsForProperty } from '../instructions/shared';
-import { isDirectiveHost } from '../interfaces/type_checks';
-import { RENDERER, TVIEW } from '../interfaces/view';
-import { getActiveDirectiveId, getCheckNoChangesMode, getCurrentStyleSanitizer, getLView, getSelectedIndex, incrementBindingIndex, nextBindingIndex, resetCurrentStyleSanitizer, setCurrentStyleSanitizer, setElementExitFn } from '../state';
-import { applyStylingMapDirectly, applyStylingValueDirectly, flushStyling, updateClassViaContext, updateStyleViaContext } from '../styling/bindings';
-import { activateStylingMapFeature } from '../styling/map_based_bindings';
-import { attachStylingDebugObject } from '../styling/styling_debug';
-import { NO_CHANGE } from '../tokens';
-import { renderStringify } from '../util/misc_utils';
-import { addItemToStylingMap, allocStylingMapArray, allocTStylingContext, allowDirectStyling, concatString, forceClassesAsString, forceStylesAsString, getInitialStylingValue, getStylingMapArray, getValue, hasClassInput, hasStyleInput, hasValueChanged, hasValueChangedUnwrapSafeValue, isHostStylingActive, isStylingContext, isStylingValueDefined, normalizeIntoStylingMap, patchConfig, selectClassBasedInputName, setValue, stylingMapToString } from '../util/styling_utils';
-import { getNativeByTNode, getTNode } from '../util/view_utils';
 /**
- * --------
- *
- * This file contains the core logic for how styling instructions are processed in Angular.
- *
- * To learn more about the algorithm see `TStylingContext`.
- *
- * --------
- */
+* @license
+* Copyright Google Inc. All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+import { unwrapSafeValue } from '../../sanitization/bypass';
+import { stylePropNeedsSanitization, ɵɵsanitizeStyle } from '../../sanitization/sanitization';
+import { keyValueArrayGet, keyValueArraySet } from '../../util/array_utils';
+import { assertDefined, assertEqual, assertLessThan, assertNotEqual, throwError } from '../../util/assert';
+import { EMPTY_ARRAY } from '../../util/empty';
+import { concatStringsWithSpace, stringify } from '../../util/stringify';
+import { assertFirstUpdatePass } from '../assert';
+import { bindingUpdated } from '../bindings';
+import { getTStylingRangeNext, getTStylingRangeNextDuplicate, getTStylingRangePrev, getTStylingRangePrevDuplicate } from '../interfaces/styling';
+import { HEADER_OFFSET, RENDERER } from '../interfaces/view';
+import { applyStyling } from '../node_manipulation';
+import { getCurrentDirectiveIndex, getCurrentStyleSanitizer, getLView, getSelectedIndex, getTView, incrementBindingIndex, setCurrentStyleSanitizer } from '../state';
+import { insertTStylingBinding } from '../styling/style_binding_list';
+import { getLastParsedKey, getLastParsedValue, parseClassName, parseClassNameNext, parseStyle, parseStyleNext } from '../styling/styling_parser';
+import { NO_CHANGE } from '../tokens';
+import { getNativeByIndex } from '../util/view_utils';
+import { setDirectiveInputsWhichShadowsStyling } from './property';
 /**
  * Sets the current style sanitizer function which will then be used
  * within all follow-up prop and map-based style binding instructions
@@ -65,49 +68,9 @@ export function ɵɵstyleSanitizer(sanitizer) {
  * @return {?}
  */
 export function ɵɵstyleProp(prop, value, suffix) {
-    stylePropInternal(getSelectedIndex(), prop, value, suffix);
+    checkStylingProperty(prop, value, suffix, false);
     return ɵɵstyleProp;
 }
-/**
- * Internal function for applying a single style to an element.
- *
- * The reason why this function has been separated from `ɵɵstyleProp` is because
- * it is also called from `ɵɵstylePropInterpolate`.
- * @param {?} elementIndex
- * @param {?} prop
- * @param {?} value
- * @param {?=} suffix
- * @return {?}
- */
-export function stylePropInternal(elementIndex, prop, value, suffix) {
-    // if a value is interpolated then it may render a `NO_CHANGE` value.
-    // in this case we do not need to do anything, but the binding index
-    // still needs to be incremented because all styling binding values
-    // are stored inside of the lView.
-    /** @type {?} */
-    const bindingIndex = nextBindingIndex();
-    /** @type {?} */
-    const lView = getLView();
-    /** @type {?} */
-    const tNode = getTNode(elementIndex, lView);
-    /** @type {?} */
-    const firstUpdatePass = lView[TVIEW].firstUpdatePass;
-    // we check for this in the instruction code so that the context can be notified
-    // about prop or map bindings so that the direct apply check can decide earlier
-    // if it allows for context resolution to be bypassed.
-    if (firstUpdatePass) {
-        patchConfig(tNode, 32768 /* hasStylePropBindings */);
-        patchHostStylingFlag(tNode, isHostStyling(), false);
-    }
-    /** @type {?} */
-    const updated = stylingProp(tNode, firstUpdatePass, lView, bindingIndex, prop, resolveStylePropValue(value, suffix), false);
-    if (ngDevMode) {
-        ngDevMode.styleProp++;
-        if (updated) {
-            ngDevMode.stylePropCacheMiss++;
-        }
-    }
-}
 /**
  * Update a class binding on an element with the provided value.
  *
@@ -125,106 +88,9 @@ export function stylePropInternal(elementIndex, prop, value, suffix) {
  * @return {?}
  */
 export function ɵɵclassProp(className, value) {
-    // if a value is interpolated then it may render a `NO_CHANGE` value.
-    // in this case we do not need to do anything, but the binding index
-    // still needs to be incremented because all styling binding values
-    // are stored inside of the lView.
-    /** @type {?} */
-    const bindingIndex = nextBindingIndex();
-    /** @type {?} */
-    const lView = getLView();
-    /** @type {?} */
-    const elementIndex = getSelectedIndex();
-    /** @type {?} */
-    const tNode = getTNode(elementIndex, lView);
-    /** @type {?} */
-    const firstUpdatePass = lView[TVIEW].firstUpdatePass;
-    // we check for this in the instruction code so that the context can be notified
-    // about prop or map bindings so that the direct apply check can decide earlier
-    // if it allows for context resolution to be bypassed.
-    if (firstUpdatePass) {
-        patchConfig(tNode, 1024 /* hasClassPropBindings */);
-        patchHostStylingFlag(tNode, isHostStyling(), true);
-    }
-    /** @type {?} */
-    const updated = stylingProp(tNode, firstUpdatePass, lView, bindingIndex, className, value, true);
-    if (ngDevMode) {
-        ngDevMode.classProp++;
-        if (updated) {
-            ngDevMode.classPropCacheMiss++;
-        }
-    }
+    checkStylingProperty(className, value, null, true);
     return ɵɵclassProp;
 }
-/**
- * Shared function used to update a prop-based styling binding for an element.
- *
- * Depending on the state of the `tNode.styles` styles context, the style/prop
- * value may be applied directly to the element instead of being processed
- * through the context. The reason why this occurs is for performance and fully
- * depends on the state of the context (i.e. whether or not there are duplicate
- * bindings or whether or not there are map-based bindings and property bindings
- * present together).
- * @param {?} tNode
- * @param {?} firstUpdatePass
- * @param {?} lView
- * @param {?} bindingIndex
- * @param {?} prop
- * @param {?} value
- * @param {?} isClassBased
- * @return {?}
- */
-function stylingProp(tNode, firstUpdatePass, lView, bindingIndex, prop, value, isClassBased) {
-    /** @type {?} */
-    let updated = false;
-    /** @type {?} */
-    const native = (/** @type {?} */ (getNativeByTNode(tNode, lView)));
-    /** @type {?} */
-    const context = isClassBased ? getClassesContext(tNode) : getStylesContext(tNode);
-    /** @type {?} */
-    const sanitizer = isClassBased ? null : getCurrentStyleSanitizer();
-    // [style.prop] and [class.name] bindings do not use `bind()` and will
-    // therefore manage accessing and updating the new value in the lView directly.
-    // For this reason, the checkNoChanges situation must also be handled here
-    // as well.
-    if (ngDevMode && getCheckNoChangesMode()) {
-        /** @type {?} */
-        const oldValue = getValue(lView, bindingIndex);
-        if (hasValueChangedUnwrapSafeValue(oldValue, value)) {
-            throwErrorIfNoChangesMode(false, oldValue, value);
-        }
-    }
-    // Direct Apply Case: bypass context resolution and apply the
-    // style/class value directly to the element
-    if (allowDirectStyling(tNode, isClassBased, firstUpdatePass)) {
-        /** @type {?} */
-        const sanitizerToUse = isClassBased ? null : sanitizer;
-        /** @type {?} */
-        const renderer = getRenderer(tNode, lView);
-        updated = applyStylingValueDirectly(renderer, context, tNode, native, lView, bindingIndex, prop, value, isClassBased, sanitizerToUse);
-        if (sanitizerToUse) {
-            // it's important we remove the current style sanitizer once the
-            // element exits, otherwise it will be used by the next styling
-            // instructions for the next element.
-            setElementExitFn(stylingApply);
-        }
-    }
-    else {
-        // Context Resolution (or first update) Case: save the value
-        // and defer to the context to flush and apply the style/class binding
-        // value to the element.
-        /** @type {?} */
-        const directiveIndex = getActiveDirectiveId();
-        if (isClassBased) {
-            updated = updateClassViaContext(context, tNode, lView, native, directiveIndex, prop, bindingIndex, (/** @type {?} */ (value)), false, firstUpdatePass);
-        }
-        else {
-            updated = updateStyleViaContext(context, tNode, lView, native, directiveIndex, prop, bindingIndex, (/** @type {?} */ (value)), sanitizer, false, firstUpdatePass);
-        }
-        setElementExitFn(stylingApply);
-    }
-    return updated;
-}
 /**
  * Update style bindings using an object literal on an element.
  *
@@ -246,41 +112,22 @@ function stylingProp(tNode, firstUpdatePass, lView, bindingIndex, prop, value, i
  * @return {?}
  */
 export function ɵɵstyleMap(styles) {
-    /** @type {?} */
-    const index = getSelectedIndex();
-    /** @type {?} */
-    const lView = getLView();
-    /** @type {?} */
-    const tNode = getTNode(index, lView);
-    /** @type {?} */
-    const firstUpdatePass = lView[TVIEW].firstUpdatePass;
-    /** @type {?} */
-    const context = getStylesContext(tNode);
-    /** @type {?} */
-    const hasDirectiveInput = hasStyleInput(tNode);
-    // if a value is interpolated then it may render a `NO_CHANGE` value.
-    // in this case we do not need to do anything, but the binding index
-    // still needs to be incremented because all styling binding values
-    // are stored inside of the lView.
-    /** @type {?} */
-    const bindingIndex = incrementBindingIndex(2);
-    /** @type {?} */
-    const hostBindingsMode = isHostStyling();
-    // inputs are only evaluated from a template binding into a directive, therefore,
-    // there should not be a situation where a directive host bindings function
-    // evaluates the inputs (this should only happen in the template function)
-    if (!hostBindingsMode && hasDirectiveInput && styles !== NO_CHANGE) {
-        updateDirectiveInputValue(context, lView, tNode, bindingIndex, styles, false, firstUpdatePass);
-        styles = NO_CHANGE;
-    }
-    // we check for this in the instruction code so that the context can be notified
-    // about prop or map bindings so that the direct apply check can decide earlier
-    // if it allows for context resolution to be bypassed.
-    if (firstUpdatePass) {
-        patchConfig(tNode, 16384 /* hasStyleMapBindings */);
-        patchHostStylingFlag(tNode, isHostStyling(), false);
-    }
-    stylingMap(context, tNode, firstUpdatePass, lView, bindingIndex, styles, false, hasDirectiveInput);
+    checkStylingMap(styleKeyValueArraySet, styleStringParser, styles, false);
+}
+/**
+ * Parse text as style and add values to KeyValueArray.
+ *
+ * This code is pulled out to a separate function so that it can be tree shaken away if it is not
+ * needed. It is only referenced from `ɵɵstyleMap`.
+ *
+ * @param {?} keyValueArray KeyValueArray to add parsed values to.
+ * @param {?} text text to parse.
+ * @return {?}
+ */
+export function styleStringParser(keyValueArray, text) {
+    for (let i = parseStyle(text); i >= 0; i = parseStyleNext(text, i)) {
+        styleKeyValueArraySet(keyValueArray, getLastParsedKey(text), getLastParsedValue(text));
+    }
 }
 /**
  * Update class bindings using an object literal or class-string on an element.
@@ -302,378 +149,793 @@ export function ɵɵstyleMap(styles) {
  * @return {?}
  */
 export function ɵɵclassMap(classes) {
-    classMapInternal(getSelectedIndex(), classes);
+    checkStylingMap(keyValueArraySet, classStringParser, classes, true);
 }
 /**
- * Internal function for applying a class string or key/value map of classes to an element.
+ * Parse text as class and add values to KeyValueArray.
+ *
+ * This code is pulled out to a separate function so that it can be tree shaken away if it is not
+ * needed. It is only referenced from `ɵɵclassMap`.
  *
- * The reason why this function has been separated from `ɵɵclassMap` is because
- * it is also called from `ɵɵclassMapInterpolate`.
- * @param {?} elementIndex
- * @param {?} classes
+ * @param {?} keyValueArray KeyValueArray to add parsed values to.
+ * @param {?} text text to parse.
  * @return {?}
  */
-export function classMapInternal(elementIndex, classes) {
+export function classStringParser(keyValueArray, text) {
+    for (let i = parseClassName(text); i >= 0; i = parseClassNameNext(text, i)) {
+        keyValueArraySet(keyValueArray, getLastParsedKey(text), true);
+    }
+}
+/**
+ * Common code between `ɵɵclassProp` and `ɵɵstyleProp`.
+ *
+ * @param {?} prop property name.
+ * @param {?} value binding value.
+ * @param {?} suffixOrSanitizer suffix or sanitization function
+ * @param {?} isClassBased `true` if `class` change (`false` if `style`)
+ * @return {?}
+ */
+export function checkStylingProperty(prop, value, suffixOrSanitizer, isClassBased) {
     /** @type {?} */
     const lView = getLView();
     /** @type {?} */
-    const tNode = getTNode(elementIndex, lView);
-    /** @type {?} */
-    const firstUpdatePass = lView[TVIEW].firstUpdatePass;
-    /** @type {?} */
-    const context = getClassesContext(tNode);
-    /** @type {?} */
-    const hasDirectiveInput = hasClassInput(tNode);
-    // if a value is interpolated then it may render a `NO_CHANGE` value.
-    // in this case we do not need to do anything, but the binding index
-    // still needs to be incremented because all styling binding values
-    // are stored inside of the lView.
+    const tView = getTView();
+    // Styling instructions use 2 slots per binding.
+    // 1. one for the value / TStylingKey
+    // 2. one for the intermittent-value / TStylingRange
     /** @type {?} */
     const bindingIndex = incrementBindingIndex(2);
-    /** @type {?} */
-    const hostBindingsMode = isHostStyling();
-    // inputs are only evaluated from a template binding into a directive, therefore,
-    // there should not be a situation where a directive host bindings function
-    // evaluates the inputs (this should only happen in the template function)
-    if (!hostBindingsMode && hasDirectiveInput && classes !== NO_CHANGE) {
-        updateDirectiveInputValue(context, lView, tNode, bindingIndex, classes, true, firstUpdatePass);
-        classes = NO_CHANGE;
-    }
-    // we check for this in the instruction code so that the context can be notified
-    // about prop or map bindings so that the direct apply check can decide earlier
-    // if it allows for context resolution to be bypassed.
-    if (firstUpdatePass) {
-        patchConfig(tNode, 512 /* hasClassMapBindings */);
-        patchHostStylingFlag(tNode, isHostStyling(), true);
-    }
-    stylingMap(context, tNode, firstUpdatePass, lView, bindingIndex, classes, true, hasDirectiveInput);
+    if (tView.firstUpdatePass) {
+        stylingFirstUpdatePass(tView, prop, bindingIndex, isClassBased);
+    }
+    if (value !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value)) {
+        // This is a work around. Once PR#34480 lands the sanitizer is passed explicitly and this line
+        // can be removed.
+        /** @type {?} */
+        let styleSanitizer;
+        if (suffixOrSanitizer == null) {
+            if (styleSanitizer = getCurrentStyleSanitizer()) {
+                suffixOrSanitizer = (/** @type {?} */ (styleSanitizer));
+            }
+        }
+        /** @type {?} */
+        const tNode = (/** @type {?} */ (tView.data[getSelectedIndex() + HEADER_OFFSET]));
+        updateStyling(tView, tNode, lView, lView[RENDERER], prop, lView[bindingIndex + 1] = normalizeAndApplySuffixOrSanitizer(value, suffixOrSanitizer), isClassBased, bindingIndex);
+    }
 }
 /**
- * Shared function used to update a map-based styling binding for an element.
- *
- * When this function is called it will activate support for `[style]` and
- * `[class]` bindings in Angular.
- * @param {?} context
- * @param {?} tNode
- * @param {?} firstUpdatePass
- * @param {?} lView
- * @param {?} bindingIndex
- * @param {?} value
- * @param {?} isClassBased
- * @param {?} hasDirectiveInput
+ * Common code between `ɵɵclassMap` and `ɵɵstyleMap`.
+ *
+ * @param {?} keyValueArraySet (See `keyValueArraySet` in "util/array_utils") Gets passed in as a
+ * function so that
+ *        `style` can pass in version which does sanitization. This is done for tree shaking
+ *        purposes.
+ * @param {?} stringParser Parser used to parse `value` if `string`. (Passed in as `style` and `class`
+ *        have different parsers.)
+ * @param {?} value bound value from application
+ * @param {?} isClassBased `true` if `class` change (`false` if `style`)
  * @return {?}
  */
-function stylingMap(context, tNode, firstUpdatePass, lView, bindingIndex, value, isClassBased, hasDirectiveInput) {
-    /** @type {?} */
-    const directiveIndex = getActiveDirectiveId();
-    /** @type {?} */
-    const native = (/** @type {?} */ (getNativeByTNode(tNode, lView)));
-    /** @type {?} */
-    const oldValue = getValue(lView, bindingIndex);
+export function checkStylingMap(keyValueArraySet, stringParser, value, isClassBased) {
     /** @type {?} */
-    const sanitizer = getCurrentStyleSanitizer();
+    const tView = getTView();
     /** @type {?} */
-    const valueHasChanged = hasValueChanged(oldValue, value);
-    // [style] and [class] bindings do not use `bind()` and will therefore
-    // manage accessing and updating the new value in the lView directly.
-    // For this reason, the checkNoChanges situation must also be handled here
-    // as well.
-    if (ngDevMode && valueHasChanged && getCheckNoChangesMode()) {
-        throwErrorIfNoChangesMode(false, oldValue, value);
-    }
-    // Direct Apply Case: bypass context resolution and apply the
-    // style/class map values directly to the element
-    if (allowDirectStyling(tNode, isClassBased, firstUpdatePass)) {
-        /** @type {?} */
-        const sanitizerToUse = isClassBased ? null : sanitizer;
-        /** @type {?} */
-        const renderer = getRenderer(tNode, lView);
-        applyStylingMapDirectly(renderer, context, tNode, native, lView, bindingIndex, value, isClassBased, sanitizerToUse, valueHasChanged, hasDirectiveInput);
-        if (sanitizerToUse) {
-            // it's important we remove the current style sanitizer once the
-            // element exits, otherwise it will be used by the next styling
-            // instructions for the next element.
-            setElementExitFn(stylingApply);
-        }
+    const bindingIndex = incrementBindingIndex(2);
+    if (tView.firstUpdatePass) {
+        stylingFirstUpdatePass(tView, null, bindingIndex, isClassBased);
     }
-    else {
+    /** @type {?} */
+    const lView = getLView();
+    if (value !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value)) {
+        // `getSelectedIndex()` should be here (rather than in instruction) so that it is guarded by the
+        // if so as not to read unnecessarily.
         /** @type {?} */
-        const stylingMapArr = value === NO_CHANGE ? NO_CHANGE : normalizeIntoStylingMap(oldValue, value, !isClassBased);
-        activateStylingMapFeature();
-        // Context Resolution (or first update) Case: save the map value
-        // and defer to the context to flush and apply the style/class binding
-        // value to the element.
-        if (isClassBased) {
-            updateClassViaContext(context, tNode, lView, native, directiveIndex, null, bindingIndex, stylingMapArr, valueHasChanged, firstUpdatePass);
+        const tNode = (/** @type {?} */ (tView.data[getSelectedIndex() + HEADER_OFFSET]));
+        if (hasStylingInputShadow(tNode, isClassBased) && !isInHostBindings(tView, bindingIndex)) {
+            if (ngDevMode) {
+                // verify that if we are shadowing then `TData` is appropriately marked so that we skip
+                // processing this binding in styling resolution.
+                /** @type {?} */
+                const tStylingKey = tView.data[bindingIndex];
+                assertEqual(Array.isArray(tStylingKey) ? tStylingKey[1] : tStylingKey, false, 'Styling linked list shadow input should be marked as \'false\'');
+            }
+            // VE does not concatenate the static portion like we are doing here.
+            // Instead VE just ignores the static completely if dynamic binding is present.
+            // Because of locality we have already set the static portion because we don't know if there
+            // is a dynamic portion until later. If we would ignore the static portion it would look like
+            // the binding has removed it. This would confuse `[ngStyle]`/`[ngClass]` to do the wrong
+            // thing as it would think that the static portion was removed. For this reason we
+            // concatenate it so that `[ngStyle]`/`[ngClass]`  can continue to work on changed.
+            /** @type {?} */
+            let staticPrefix = isClassBased ? tNode.classes : tNode.styles;
+            ngDevMode && isClassBased === false && staticPrefix !== null &&
+                assertEqual(staticPrefix.endsWith(';'), true, 'Expecting static portion to end with \';\'');
+            if (typeof value === 'string') {
+                value = concatStringsWithSpace(staticPrefix, (/** @type {?} */ (value)));
+            }
+            // Given `<div [style] my-dir>` such that `my-dir` has `@Input('style')`.
+            // This takes over the `[style]` binding. (Same for `[class]`)
+            setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value, isClassBased);
         }
         else {
-            updateStyleViaContext(context, tNode, lView, native, directiveIndex, null, bindingIndex, stylingMapArr, sanitizer, valueHasChanged, firstUpdatePass);
-        }
-        setElementExitFn(stylingApply);
-    }
-    if (ngDevMode) {
-        isClassBased ? ngDevMode.classMap : ngDevMode.styleMap++;
-        if (valueHasChanged) {
-            isClassBased ? ngDevMode.classMapCacheMiss : ngDevMode.styleMapCacheMiss++;
+            updateStylingMap(tView, tNode, lView, lView[RENDERER], lView[bindingIndex + 1], lView[bindingIndex + 1] = toStylingKeyValueArray(keyValueArraySet, stringParser, value), isClassBased, bindingIndex);
         }
     }
 }
 /**
- * Writes a value to a directive's `style` or `class` input binding (if it has changed).
- *
- * If a directive has a `\@Input` binding that is set on `style` or `class` then that value
- * will take priority over the underlying style/class styling bindings. This value will
- * be updated for the binding each time during change detection.
- *
- * When this occurs this function will attempt to write the value to the input binding
- * depending on the following situations:
- *
- * - If `oldValue !== newValue`
- * - If `newValue` is `null` (but this is skipped if it is during the first update pass)
- * @param {?} context
- * @param {?} lView
- * @param {?} tNode
- * @param {?} bindingIndex
- * @param {?} newValue
- * @param {?} isClassBased
- * @param {?} firstUpdatePass
+ * Determines when the binding is in `hostBindings` section
+ *
+ * @param {?} tView Current `TView`
+ * @param {?} bindingIndex index of binding which we would like if it is in `hostBindings`
  * @return {?}
  */
-function updateDirectiveInputValue(context, lView, tNode, bindingIndex, newValue, isClassBased, firstUpdatePass) {
-    /** @type {?} */
-    const oldValue = getValue(lView, bindingIndex);
-    if (hasValueChanged(oldValue, newValue)) {
-        // even if the value has changed we may not want to emit it to the
-        // directive input(s) in the event that it is falsy during the
-        // first update pass.
-        if (isStylingValueDefined(newValue) || !firstUpdatePass) {
-            /** @type {?} */
-            const inputName = isClassBased ? selectClassBasedInputName((/** @type {?} */ (tNode.inputs))) : 'style';
-            /** @type {?} */
-            const inputs = (/** @type {?} */ ((/** @type {?} */ (tNode.inputs))[inputName]));
-            /** @type {?} */
-            const initialValue = getInitialStylingValue(context);
-            /** @type {?} */
-            const value = normalizeStylingDirectiveInputValue(initialValue, newValue, isClassBased);
-            setInputsForProperty(lView, inputs, inputName, value);
-            setElementExitFn(stylingApply);
+function isInHostBindings(tView, bindingIndex) {
+    // All host bindings are placed after the expando section.
+    return bindingIndex >= tView.expandoStartIndex;
+}
+/**
+ * Collects the necessary information to insert the binding into a linked list of style bindings
+ * using `insertTStylingBinding`.
+ *
+ * @param {?} tView `TView` where the binding linked list will be stored.
+ * @param {?} tStylingKey Property/key of the binding.
+ * @param {?} bindingIndex Index of binding associated with the `prop`
+ * @param {?} isClassBased `true` if `class` change (`false` if `style`)
+ * @return {?}
+ */
+function stylingFirstUpdatePass(tView, tStylingKey, bindingIndex, isClassBased) {
+    ngDevMode && assertFirstUpdatePass(tView);
+    /** @type {?} */
+    const tData = tView.data;
+    if (tData[bindingIndex + 1] === null) {
+        // The above check is necessary because we don't clear first update pass until first successful
+        // (no exception) template execution. This prevents the styling instruction from double adding
+        // itself to the list.
+        // `getSelectedIndex()` should be here (rather than in instruction) so that it is guarded by the
+        // if so as not to read unnecessarily.
+        /** @type {?} */
+        const tNode = (/** @type {?} */ (tData[getSelectedIndex() + HEADER_OFFSET]));
+        /** @type {?} */
+        const isHostBindings = isInHostBindings(tView, bindingIndex);
+        if (hasStylingInputShadow(tNode, isClassBased) && tStylingKey === null && !isHostBindings) {
+            // `tStylingKey === null` implies that we are either `[style]` or `[class]` binding.
+            // If there is a directive which uses `@Input('style')` or `@Input('class')` than
+            // we need to neutralize this binding since that directive is shadowing it.
+            // We turn this into a noop by setting the key to `false`
+            tStylingKey = false;
         }
-        setValue(lView, bindingIndex, newValue);
+        tStylingKey = wrapInStaticStylingKey(tData, tNode, tStylingKey, isClassBased);
+        insertTStylingBinding(tData, tNode, tStylingKey, bindingIndex, isHostBindings, isClassBased);
     }
 }
 /**
- * Returns the appropriate directive input value for `style` or `class`.
- *
- * Earlier versions of Angular expect a binding value to be passed into directive code
- * exactly as it is unless there is a static value present (in which case both values
- * will be stringified and concatenated).
- * @param {?} initialValue
- * @param {?} bindingValue
- * @param {?} isClassBased
+ * Adds static styling information to the binding if applicable.
+ *
+ * The linked list of styles not only stores the list and keys, but also stores static styling
+ * information on some of the keys. This function determines if the key should contain the styling
+ * information and computes it.
+ *
+ * See `TStylingStatic` for more details.
+ *
+ * @param {?} tData `TData` where the linked list is stored.
+ * @param {?} tNode `TNode` for which the styling is being computed.
+ * @param {?} stylingKey `TStylingKeyPrimitive` which may need to be wrapped into `TStylingKey`
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
  * @return {?}
  */
-function normalizeStylingDirectiveInputValue(initialValue, bindingValue, isClassBased) {
+export function wrapInStaticStylingKey(tData, tNode, stylingKey, isClassBased) {
     /** @type {?} */
-    let value = bindingValue;
-    // we only concat values if there is an initial value, otherwise we return the value as is.
-    // Note that this is to satisfy backwards-compatibility in Angular.
-    if (initialValue.length) {
-        if (isClassBased) {
-            value = concatString(initialValue, forceClassesAsString(bindingValue));
+    const hostDirectiveDef = getHostDirectiveDef(tData);
+    /** @type {?} */
+    let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;
+    if (hostDirectiveDef === null) {
+        // We are in template node.
+        // If template node already had styling instruction then it has already collected the static
+        // styling and there is no need to collect them again. We know that we are the first styling
+        // instruction because the `TNode.*Bindings` points to 0 (nothing has been inserted yet).
+        /** @type {?} */
+        const isFirstStylingInstructionInTemplate = (/** @type {?} */ ((/** @type {?} */ ((isClassBased ? tNode.classBindings : tNode.styleBindings))))) === 0;
+        if (isFirstStylingInstructionInTemplate) {
+            // It would be nice to be able to get the statics from `mergeAttrs`, however, at this point
+            // they are already merged and it would not be possible to figure which property belongs where
+            // in the priority.
+            stylingKey = collectStylingFromDirectives(null, tData, tNode, stylingKey, isClassBased);
+            stylingKey = collectStylingFromTAttrs(stylingKey, tNode.attrs, isClassBased);
+            // We know that if we have styling binding in template we can't have residual.
+            residual = null;
         }
-        else {
-            value = concatString(initialValue, forceStylesAsString(bindingValue, true), ';');
+    }
+    else {
+        // We are in host binding node and there was no binding instruction in template node.
+        // This means that we need to compute the residual.
+        /** @type {?} */
+        const directiveStylingLast = tNode.directiveStylingLast;
+        /** @type {?} */
+        const isFirstStylingInstructionInHostBinding = directiveStylingLast === -1 || tData[directiveStylingLast] !== hostDirectiveDef;
+        if (isFirstStylingInstructionInHostBinding) {
+            stylingKey =
+                collectStylingFromDirectives(hostDirectiveDef, tData, tNode, stylingKey, isClassBased);
+            if (residual === null) {
+                // - If `null` than either:
+                //    - Template styling instruction already ran and it has consumed the static
+                //      styling into its `TStylingKey` and so there is no need to update residual. Instead
+                //      we need to update the `TStylingKey` associated with the first template node
+                //      instruction. OR
+                //    - Some other styling instruction ran and determined that there are no residuals
+                /** @type {?} */
+                let templateStylingKey = getTemplateHeadTStylingKey(tData, tNode, isClassBased);
+                if (templateStylingKey !== undefined && Array.isArray(templateStylingKey)) {
+                    // Only recompute if `templateStylingKey` had static values. (If no static value found
+                    // then there is nothing to do since this operation can only produce less static keys, not
+                    // more.)
+                    templateStylingKey = collectStylingFromDirectives(null, tData, tNode, templateStylingKey[1] /* unwrap previous statics */, isClassBased);
+                    templateStylingKey =
+                        collectStylingFromTAttrs(templateStylingKey, tNode.attrs, isClassBased);
+                    setTemplateHeadTStylingKey(tData, tNode, isClassBased, templateStylingKey);
+                }
+            }
+            else {
+                // We only need to recompute residual if it is not `null`.
+                // - If existing residual (implies there was no template styling). This means that some of
+                //   the statics may have moved from the residual to the `stylingKey` and so we have to
+                //   recompute.
+                // - If `undefined` this is the first time we are running.
+                residual = collectResidual(tData, tNode, isClassBased);
+            }
         }
     }
-    return value;
+    if (residual !== undefined) {
+        isClassBased ? (tNode.residualClasses = residual) : (tNode.residualStyles = residual);
+    }
+    return stylingKey;
 }
 /**
- * Flushes all styling code to the element.
+ * Retrieve the `TStylingKey` for the template styling instruction.
  *
- * This function is designed to be scheduled from any of the four styling instructions
- * in this file. When called it will flush all style and class bindings to the element
- * via the context resolution algorithm.
- * @return {?}
+ * This is needed since `hostBinding` styling instructions are inserted after the template
+ * instruction. While the template instruction needs to update the residual in `TNode` the
+ * `hostBinding` instructions need to update the `TStylingKey` of the template instruction because
+ * the template instruction is downstream from the `hostBindings` instructions.
+ *
+ * @param {?} tData `TData` where the linked list is stored.
+ * @param {?} tNode `TNode` for which the styling is being computed.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
+ * @return {?} `TStylingKey` if found or `undefined` if not found.
  */
-function stylingApply() {
-    /** @type {?} */
-    const lView = getLView();
+function getTemplateHeadTStylingKey(tData, tNode, isClassBased) {
     /** @type {?} */
-    const tView = lView[TVIEW];
+    const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;
+    if (getTStylingRangeNext(bindings) === 0) {
+        // There does not seem to be a styling instruction in the `template`.
+        return undefined;
+    }
+    return (/** @type {?} */ (tData[getTStylingRangePrev(bindings)]));
+}
+/**
+ * Update the `TStylingKey` of the first template instruction in `TNode`.
+ *
+ * Logically `hostBindings` styling instructions are of lower priority than that of the template.
+ * However, they execute after the template styling instructions. This means that they get inserted
+ * in front of the template styling instructions.
+ *
+ * If we have a template styling instruction and a new `hostBindings` styling instruction is
+ * executed it means that it may need to steal static fields from the template instruction. This
+ * method allows us to update the first template instruction `TStylingKey` with a new value.
+ *
+ * Assume:
+ * ```
+ * <div my-dir style="color: red" [style.color]="tmplExp"></div>
+ *
+ * \@Directive({
+ *   host: {
+ *     'style': 'width: 100px',
+ *     '[style.color]': 'dirExp',
+ *   }
+ * })
+ * class MyDir {}
+ * ```
+ *
+ * when `[style.color]="tmplExp"` executes it creates this data structure.
+ * ```
+ *  ['', 'color', 'color', 'red', 'width', '100px'],
+ * ```
+ *
+ * The reason for this is that the template instruction does not know if there are styling
+ * instructions and must assume that there are none and must collect all of the static styling.
+ * (both
+ * `color' and 'width`)
+ *
+ * When `'[style.color]': 'dirExp',` executes we need to insert a new data into the linked list.
+ * ```
+ *  ['', 'color', 'width', '100px'],  // newly inserted
+ *  ['', 'color', 'color', 'red', 'width', '100px'], // this is wrong
+ * ```
+ *
+ * Notice that the template statics is now wrong as it incorrectly contains `width` so we need to
+ * update it like so:
+ * ```
+ *  ['', 'color', 'width', '100px'],
+ *  ['', 'color', 'color', 'red'],    // UPDATE
+ * ```
+ *
+ * @param {?} tData `TData` where the linked list is stored.
+ * @param {?} tNode `TNode` for which the styling is being computed.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
+ * @param {?} tStylingKey New `TStylingKey` which is replacing the old one.
+ * @return {?}
+ */
+function setTemplateHeadTStylingKey(tData, tNode, isClassBased, tStylingKey) {
     /** @type {?} */
-    const elementIndex = getSelectedIndex();
+    const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;
+    ngDevMode && assertNotEqual(getTStylingRangeNext(bindings), 0, 'Expecting to have at least one template styling binding.');
+    tData[getTStylingRangePrev(bindings)] = tStylingKey;
+}
+/**
+ * Collect all static values after the current `TNode.directiveStylingLast` index.
+ *
+ * Collect the remaining styling information which has not yet been collected by an existing
+ * styling instruction.
+ *
+ * @param {?} tData `TData` where the `DirectiveDefs` are stored.
+ * @param {?} tNode `TNode` which contains the directive range.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
+ * @return {?}
+ */
+function collectResidual(tData, tNode, isClassBased) {
     /** @type {?} */
-    const tNode = getTNode(elementIndex, lView);
+    let residual = undefined;
     /** @type {?} */
-    const native = (/** @type {?} */ (getNativeByTNode(tNode, lView)));
+    const directiveEnd = tNode.directiveEnd;
+    ngDevMode &&
+        assertNotEqual(tNode.directiveStylingLast, -1, 'By the time this function gets called at least one hostBindings-node styling instruction must have executed.');
+    // We add `1 + tNode.directiveStart` because we need to skip the current directive (as we are
+    // collecting things after the last `hostBindings` directive which had a styling instruction.)
+    for (let i = 1 + tNode.directiveStylingLast; i < directiveEnd; i++) {
+        /** @type {?} */
+        const attrs = ((/** @type {?} */ (tData[i]))).hostAttrs;
+        residual = (/** @type {?} */ (collectStylingFromTAttrs(residual, attrs, isClassBased)));
+    }
+    return (/** @type {?} */ (collectStylingFromTAttrs(residual, tNode.attrs, isClassBased)));
+}
+/**
+ * Collect the static styling information with lower priority than `hostDirectiveDef`.
+ *
+ * (This is opposite of residual styling.)
+ *
+ * @param {?} hostDirectiveDef `DirectiveDef` for which we want to collect lower priority static
+ *        styling. (Or `null` if template styling)
+ * @param {?} tData `TData` where the linked list is stored.
+ * @param {?} tNode `TNode` for which the styling is being computed.
+ * @param {?} stylingKey Existing `TStylingKey` to update or wrap.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
+ * @return {?}
+ */
+function collectStylingFromDirectives(hostDirectiveDef, tData, tNode, stylingKey, isClassBased) {
+    // We need to loop because there can be directives which have `hostAttrs` but don't have
+    // `hostBindings` so this loop catches up to the current directive..
     /** @type {?} */
-    const directiveIndex = getActiveDirectiveId();
+    let currentDirective = null;
     /** @type {?} */
-    const renderer = getRenderer(tNode, lView);
+    const directiveEnd = tNode.directiveEnd;
     /** @type {?} */
-    const sanitizer = getCurrentStyleSanitizer();
+    let directiveStylingLast = tNode.directiveStylingLast;
+    if (directiveStylingLast === -1) {
+        directiveStylingLast = tNode.directiveStart;
+    }
+    else {
+        directiveStylingLast++;
+    }
+    while (directiveStylingLast < directiveEnd) {
+        currentDirective = (/** @type {?} */ (tData[directiveStylingLast]));
+        ngDevMode && assertDefined(currentDirective, 'expected to be defined');
+        stylingKey = collectStylingFromTAttrs(stylingKey, currentDirective.hostAttrs, isClassBased);
+        if (currentDirective === hostDirectiveDef)
+            break;
+        directiveStylingLast++;
+    }
+    if (hostDirectiveDef !== null) {
+        // we only advance the styling cursor if we are collecting data from host bindings.
+        // Template executes before host bindings and so if we would update the index,
+        // host bindings would not get their statics.
+        tNode.directiveStylingLast = directiveStylingLast;
+    }
+    return stylingKey;
+}
+/**
+ * Convert `TAttrs` into `TStylingStatic`.
+ *
+ * @param {?} stylingKey existing `TStylingKey` to update or wrap.
+ * @param {?} attrs `TAttributes` to process.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
+ * @return {?}
+ */
+function collectStylingFromTAttrs(stylingKey, attrs, isClassBased) {
     /** @type {?} */
-    const classesContext = isStylingContext(tNode.classes) ? (/** @type {?} */ (tNode.classes)) : null;
+    const desiredMarker = isClassBased ? 1 /* Classes */ : 2 /* Styles */;
     /** @type {?} */
-    const stylesContext = isStylingContext(tNode.styles) ? (/** @type {?} */ (tNode.styles)) : null;
-    flushStyling(renderer, lView, tNode, classesContext, stylesContext, native, directiveIndex, sanitizer, tView.firstUpdatePass);
-    resetCurrentStyleSanitizer();
+    let currentMarker = -1 /* ImplicitAttributes */;
+    if (attrs !== null) {
+        for (let i = 0; i < attrs.length; i++) {
+            /** @type {?} */
+            const item = (/** @type {?} */ (attrs[i]));
+            if (typeof item === 'number') {
+                currentMarker = item;
+            }
+            else {
+                if (currentMarker === desiredMarker) {
+                    if (!Array.isArray(stylingKey)) {
+                        stylingKey = stylingKey === undefined ? [] : (/** @type {?} */ (['', stylingKey]));
+                    }
+                    keyValueArraySet((/** @type {?} */ (stylingKey)), item, isClassBased ? true : attrs[++i]);
+                }
+            }
+        }
+    }
+    return stylingKey === undefined ? null : stylingKey;
 }
 /**
- * @param {?} tNode
- * @param {?} lView
+ * Retrieve the current `DirectiveDef` which is active when `hostBindings` style instruction is
+ * being executed (or `null` if we are in `template`.)
+ *
+ * @param {?} tData Current `TData` where the `DirectiveDef` will be looked up at.
  * @return {?}
  */
-function getRenderer(tNode, lView) {
-    return tNode.type === 3 /* Element */ ? lView[RENDERER] : null;
+export function getHostDirectiveDef(tData) {
+    /** @type {?} */
+    const currentDirectiveIndex = getCurrentDirectiveIndex();
+    return currentDirectiveIndex === -1 ? null : (/** @type {?} */ (tData[currentDirectiveIndex]));
 }
 /**
- * Searches and assigns provided all static style/class entries (found in the `attrs` value)
- * and registers them in their respective styling contexts.
- * @param {?} tNode
- * @param {?} attrs
- * @param {?} startIndex
+ * Convert user input to `KeyValueArray`.
+ *
+ * This function takes user input which could be `string`, Object literal, or iterable and converts
+ * it into a consistent representation. The output of this is `KeyValueArray` (which is an array
+ * where
+ * even indexes contain keys and odd indexes contain values for those keys).
+ *
+ * The advantage of converting to `KeyValueArray` is that we can perform diff in an input
+ * independent
+ * way.
+ * (ie we can compare `foo bar` to `['bar', 'baz'] and determine a set of changes which need to be
+ * applied)
+ *
+ * The fact that `KeyValueArray` is sorted is very important because it allows us to compute the
+ * difference in linear fashion without the need to allocate any additional data.
+ *
+ * For example if we kept this as a `Map` we would have to iterate over previous `Map` to determine
+ * which values need to be deleted, over the new `Map` to determine additions, and we would have to
+ * keep additional `Map` to keep track of duplicates or items which have not yet been visited.
+ *
+ * @param {?} keyValueArraySet (See `keyValueArraySet` in "util/array_utils") Gets passed in as a
+ * function so that
+ *        `style` can pass in version which does sanitization. This is done for tree shaking
+ *        purposes.
+ * @param {?} stringParser The parser is passed in so that it will be tree shakable. See
+ *        `styleStringParser` and `classStringParser`
+ * @param {?} value The value to parse/convert to `KeyValueArray`
  * @return {?}
  */
-export function registerInitialStylingOnTNode(tNode, attrs, startIndex) {
-    /** @type {?} */
-    let hasAdditionalInitialStyling = false;
-    /** @type {?} */
-    let styles = getStylingMapArray(tNode.styles);
-    /** @type {?} */
-    let classes = getStylingMapArray(tNode.classes);
-    /** @type {?} */
-    let mode = -1;
-    for (let i = startIndex; i < attrs.length; i++) {
-        /** @type {?} */
-        const attr = (/** @type {?} */ (attrs[i]));
-        if (typeof attr == 'number') {
-            mode = attr;
+export function toStylingKeyValueArray(keyValueArraySet, stringParser, value) {
+    if (value == null /*|| value === undefined */ || value === '')
+        return (/** @type {?} */ (EMPTY_ARRAY));
+    /** @type {?} */
+    const styleKeyValueArray = (/** @type {?} */ ([]));
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            keyValueArraySet(styleKeyValueArray, value[i], true);
         }
-        else if (mode == 1 /* Classes */) {
-            classes = classes || allocStylingMapArray(null);
-            addItemToStylingMap(classes, attr, true);
-            hasAdditionalInitialStyling = true;
+    }
+    else if (typeof value === 'object') {
+        if (value instanceof Map) {
+            value.forEach((/**
+             * @param {?} v
+             * @param {?} k
+             * @return {?}
+             */
+            (v, k) => keyValueArraySet(styleKeyValueArray, k, v)));
         }
-        else if (mode == 2 /* Styles */) {
-            /** @type {?} */
-            const value = (/** @type {?} */ (attrs[++i]));
-            styles = styles || allocStylingMapArray(null);
-            addItemToStylingMap(styles, attr, value);
-            hasAdditionalInitialStyling = true;
+        else if (value instanceof Set) {
+            value.forEach((/**
+             * @param {?} k
+             * @return {?}
+             */
+            (k) => keyValueArraySet(styleKeyValueArray, k, true)));
         }
-    }
-    if (classes && classes.length > 1 /* ValuesStartPosition */) {
-        if (!tNode.classes) {
-            tNode.classes = classes;
+        else {
+            for (const key in value) {
+                if (value.hasOwnProperty(key)) {
+                    keyValueArraySet(styleKeyValueArray, key, value[key]);
+                }
+            }
         }
-        updateRawValueOnContext(tNode.classes, stylingMapToString(classes, true));
     }
-    if (styles && styles.length > 1 /* ValuesStartPosition */) {
-        if (!tNode.styles) {
-            tNode.styles = styles;
-        }
-        updateRawValueOnContext(tNode.styles, stylingMapToString(styles, false));
+    else if (typeof value === 'string') {
+        stringParser(styleKeyValueArray, value);
     }
-    if (hasAdditionalInitialStyling) {
-        tNode.flags |= 256 /* hasInitialStyling */;
+    else {
+        ngDevMode && throwError('Unsupported styling type ' + typeof value + ': ' + value);
     }
-    return hasAdditionalInitialStyling;
+    return styleKeyValueArray;
 }
 /**
- * @param {?} context
- * @param {?} value
+ * Set a `value` for a `key` taking style sanitization into account.
+ *
+ * See: `keyValueArraySet` for details
+ *
+ * @param {?} keyValueArray KeyValueArray to add to.
+ * @param {?} key Style key to add. (This key will be checked if it needs sanitization)
+ * @param {?} value The value to set (If key needs sanitization it will be sanitized)
  * @return {?}
  */
-function updateRawValueOnContext(context, value) {
-    /** @type {?} */
-    const stylingMapArr = (/** @type {?} */ (getStylingMapArray(context)));
-    stylingMapArr[0 /* RawValuePosition */] = value;
+function styleKeyValueArraySet(keyValueArray, key, value) {
+    if (stylePropNeedsSanitization(key)) {
+        value = ɵɵsanitizeStyle(value);
+    }
+    keyValueArraySet(keyValueArray, key, value);
 }
 /**
- * @param {?} tNode
+ * Update map based styling.
+ *
+ * Map based styling could be anything which contains more than one binding. For example `string`,
+ * `Map`, `Set` or object literal. Dealing with all of these types would complicate the logic so
+ * instead this function expects that the complex input is first converted into normalized
+ * `KeyValueArray`. The advantage of normalization is that we get the values sorted, which makes it
+ * very
+ * cheap to compute deltas between the previous and current value.
+ *
+ * @param {?} tView Associated `TView.data` contains the linked list of binding priorities.
+ * @param {?} tNode `TNode` where the binding is located.
+ * @param {?} lView `LView` contains the values associated with other styling binding at this `TNode`.
+ * @param {?} renderer Renderer to use if any updates.
+ * @param {?} oldKeyValueArray Previous value represented as `KeyValueArray`
+ * @param {?} newKeyValueArray Current value represented as `KeyValueArray`
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
+ * @param {?} bindingIndex Binding index of the binding.
  * @return {?}
  */
-function getStylesContext(tNode) {
-    return getContext(tNode, false);
+function updateStylingMap(tView, tNode, lView, renderer, oldKeyValueArray, newKeyValueArray, isClassBased, bindingIndex) {
+    if ((/** @type {?} */ (oldKeyValueArray)) === NO_CHANGE) {
+        // On first execution the oldKeyValueArray is NO_CHANGE => treat it as empty KeyValueArray.
+        oldKeyValueArray = (/** @type {?} */ (EMPTY_ARRAY));
+    }
+    /** @type {?} */
+    let oldIndex = 0;
+    /** @type {?} */
+    let newIndex = 0;
+    /** @type {?} */
+    let oldKey = 0 < oldKeyValueArray.length ? oldKeyValueArray[0] : null;
+    /** @type {?} */
+    let newKey = 0 < newKeyValueArray.length ? newKeyValueArray[0] : null;
+    while (oldKey !== null || newKey !== null) {
+        ngDevMode && assertLessThan(oldIndex, 999, 'Are we stuck in infinite loop?');
+        ngDevMode && assertLessThan(newIndex, 999, 'Are we stuck in infinite loop?');
+        /** @type {?} */
+        const oldValue = oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex + 1] : undefined;
+        /** @type {?} */
+        const newValue = newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex + 1] : undefined;
+        /** @type {?} */
+        let setKey = null;
+        /** @type {?} */
+        let setValue = undefined;
+        if (oldKey === newKey) {
+            // UPDATE: Keys are equal => new value is overwriting old value.
+            oldIndex += 2;
+            newIndex += 2;
+            if (oldValue !== newValue) {
+                setKey = newKey;
+                setValue = newValue;
+            }
+        }
+        else if (newKey === null || oldKey !== null && oldKey < (/** @type {?} */ (newKey))) {
+            // DELETE: oldKey key is missing or we did not find the oldKey in the newValue
+            // (because the keyValueArray is sorted and `newKey` is found later alphabetically).
+            // `"background" < "color"` so we need to delete `"background"` because it is not found in the
+            // new array.
+            oldIndex += 2;
+            setKey = oldKey;
+        }
+        else {
+            // CREATE: newKey's is earlier alphabetically than oldKey's (or no oldKey) => we have new key.
+            // `"color" > "background"` so we need to add `color` because it is in new array but not in
+            // old array.
+            ngDevMode && assertDefined(newKey, 'Expecting to have a valid key');
+            newIndex += 2;
+            setKey = newKey;
+            setValue = newValue;
+        }
+        if (setKey !== null) {
+            updateStyling(tView, tNode, lView, renderer, setKey, setValue, isClassBased, bindingIndex);
+        }
+        oldKey = oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex] : null;
+        newKey = newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex] : null;
+    }
 }
 /**
- * @param {?} tNode
+ * Update a simple (property name) styling.
+ *
+ * This function takes `prop` and updates the DOM to that value. The function takes the binding
+ * value as well as binding priority into consideration to determine which value should be written
+ * to DOM. (For example it may be determined that there is a higher priority overwrite which blocks
+ * the DOM write, or if the value goes to `undefined` a lower priority overwrite may be consulted.)
+ *
+ * @param {?} tView Associated `TView.data` contains the linked list of binding priorities.
+ * @param {?} tNode `TNode` where the binding is located.
+ * @param {?} lView `LView` contains the values associated with other styling binding at this `TNode`.
+ * @param {?} renderer Renderer to use if any updates.
+ * @param {?} prop Either style property name or a class name.
+ * @param {?} value Either style value for `prop` or `true`/`false` if `prop` is class.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
+ * @param {?} bindingIndex Binding index of the binding.
  * @return {?}
  */
-function getClassesContext(tNode) {
-    return getContext(tNode, true);
+function updateStyling(tView, tNode, lView, renderer, prop, value, isClassBased, bindingIndex) {
+    if (tNode.type !== 3 /* Element */) {
+        // It is possible to have styling on non-elements (such as ng-container).
+        // This is rare, but it does happen. In such a case, just ignore the binding.
+        return;
+    }
+    /** @type {?} */
+    const tData = tView.data;
+    /** @type {?} */
+    const tRange = (/** @type {?} */ (tData[bindingIndex + 1]));
+    /** @type {?} */
+    const higherPriorityValue = getTStylingRangeNextDuplicate(tRange) ?
+        findStylingValue(tData, tNode, lView, prop, getTStylingRangeNext(tRange), isClassBased) :
+        undefined;
+    if (!isStylingValuePresent(higherPriorityValue)) {
+        // We don't have a next duplicate, or we did not find a duplicate value.
+        if (!isStylingValuePresent(value)) {
+            // We should delete current value or restore to lower priority value.
+            if (getTStylingRangePrevDuplicate(tRange)) {
+                // We have a possible prev duplicate, let's retrieve it.
+                value = findStylingValue(tData, null, lView, prop, bindingIndex, isClassBased);
+            }
+        }
+        /** @type {?} */
+        const rNode = (/** @type {?} */ (getNativeByIndex(getSelectedIndex(), lView)));
+        applyStyling(renderer, isClassBased, rNode, prop, value);
+    }
 }
 /**
- * Returns/instantiates a styling context from/to a `tNode` instance.
- * @param {?} tNode
- * @param {?} isClassBased
+ * Search for styling value with higher priority which is overwriting current value, or a
+ * value of lower priority to which we should fall back if the value is `undefined`.
+ *
+ * When value is being applied at a location, related values need to be consulted.
+ * - If there is a higher priority binding, we should be using that one instead.
+ *   For example `<div  [style]="{color:exp1}" [style.color]="exp2">` change to `exp1`
+ *   requires that we check `exp2` to see if it is set to value other than `undefined`.
+ * - If there is a lower priority binding and we are changing to `undefined`
+ *   For example `<div  [style]="{color:exp1}" [style.color]="exp2">` change to `exp2` to
+ *   `undefined` requires that we check `exp1` (and static values) and use that as new value.
+ *
+ * NOTE: The styling stores two values.
+ * 1. The raw value which came from the application is stored at `index + 0` location. (This value
+ *    is used for dirty checking).
+ * 2. The normalized value (converted to `KeyValueArray` if map and sanitized) is stored at `index +
+ * 1`.
+ *    The advantage of storing the sanitized value is that once the value is written we don't need
+ *    to worry about sanitizing it later or keeping track of the sanitizer.
+ *
+ * @param {?} tData `TData` used for traversing the priority.
+ * @param {?} tNode `TNode` to use for resolving static styling. Also controls search direction.
+ *   - `TNode` search next and quit as soon as `isStylingValuePresent(value)` is true.
+ *      If no value found consult `tNode.residualStyle`/`tNode.residualClass` for default value.
+ *   - `null` search prev and go all the way to end. Return last value where
+ *     `isStylingValuePresent(value)` is true.
+ * @param {?} lView `LView` used for retrieving the actual values.
+ * @param {?} prop Property which we are interested in.
+ * @param {?} index Starting index in the linked list of styling bindings where the search should start.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
  * @return {?}
  */
-function getContext(tNode, isClassBased) {
+function findStylingValue(tData, tNode, lView, prop, index, isClassBased) {
+    // `TNode` to use for resolving static styling. Also controls search direction.
+    //   - `TNode` search next and quit as soon as `isStylingValuePresent(value)` is true.
+    //      If no value found consult `tNode.residualStyle`/`tNode.residualClass` for default value.
+    //   - `null` search prev and go all the way to end. Return last value where
+    //     `isStylingValuePresent(value)` is true.
+    /** @type {?} */
+    const isPrevDirection = tNode === null;
     /** @type {?} */
-    let context = isClassBased ? tNode.classes : tNode.styles;
-    if (!isStylingContext(context)) {
+    let value = undefined;
+    while (index > 0) {
         /** @type {?} */
-        const hasDirectives = isDirectiveHost(tNode);
-        context = allocTStylingContext((/** @type {?} */ (context)), hasDirectives);
-        if (ngDevMode) {
-            attachStylingDebugObject((/** @type {?} */ (context)), tNode, isClassBased);
+        const rawKey = (/** @type {?} */ (tData[index]));
+        /** @type {?} */
+        const containsStatics = Array.isArray(rawKey);
+        // Unwrap the key if we contain static values.
+        /** @type {?} */
+        const key = containsStatics ? ((/** @type {?} */ (rawKey)))[1] : rawKey;
+        /** @type {?} */
+        const isStylingMap = key === null;
+        /** @type {?} */
+        let valueAtLViewIndex = lView[index + 1];
+        if (valueAtLViewIndex === NO_CHANGE) {
+            // In firstUpdatePass the styling instructions create a linked list of styling.
+            // On subsequent passes it is possible for a styling instruction to try to read a binding
+            // which
+            // has not yet executed. In that case we will find `NO_CHANGE` and we should assume that
+            // we have `undefined` (or empty array in case of styling-map instruction) instead. This
+            // allows the resolution to apply the value (which may later be overwritten when the
+            // binding actually executes.)
+            valueAtLViewIndex = isStylingMap ? EMPTY_ARRAY : undefined;
         }
-        if (isClassBased) {
-            tNode.classes = context;
+        /** @type {?} */
+        let currentValue = isStylingMap ? keyValueArrayGet(valueAtLViewIndex, prop) :
+            key === prop ? valueAtLViewIndex : undefined;
+        if (containsStatics && !isStylingValuePresent(currentValue)) {
+            currentValue = keyValueArrayGet((/** @type {?} */ (rawKey)), prop);
         }
-        else {
-            tNode.styles = context;
+        if (isStylingValuePresent(currentValue)) {
+            value = currentValue;
+            if (isPrevDirection) {
+                return value;
+            }
+        }
+        /** @type {?} */
+        const tRange = (/** @type {?} */ (tData[index + 1]));
+        index = isPrevDirection ? getTStylingRangePrev(tRange) : getTStylingRangeNext(tRange);
+    }
+    if (tNode !== null) {
+        // in case where we are going in next direction AND we did not find anything, we need to
+        // consult residual styling
+        /** @type {?} */
+        let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;
+        if (residual != null /** OR residual !=== undefined */) {
+            value = keyValueArrayGet((/** @type {?} */ (residual)), prop);
         }
     }
-    return (/** @type {?} */ (context));
+    return value;
 }
 /**
- * @param {?} value
- * @param {?} suffix
+ * Determines if the binding value should be used (or if the value is 'undefined' and hence priority
+ * resolution should be used.)
+ *
+ * @param {?} value Binding style value.
  * @return {?}
  */
-function resolveStylePropValue(value, suffix) {
-    if (value === NO_CHANGE)
-        return value;
-    /** @type {?} */
-    let resolvedValue = null;
-    if (isStylingValueDefined(value)) {
-        if (suffix) {
-            // when a suffix is applied then it will bypass
-            // sanitization entirely (b/c a new string is created)
-            resolvedValue = renderStringify(value) + suffix;
-        }
-        else {
-            // sanitization happens by dealing with a string value
-            // this means that the string value will be passed through
-            // into the style rendering later (which is where the value
-            // will be sanitized before it is applied)
-            resolvedValue = (/** @type {?} */ ((/** @type {?} */ (value))));
-        }
-    }
-    return resolvedValue;
+function isStylingValuePresent(value) {
+    // Currently only `undefined` value is considered non-binding. That is `undefined` says I don't
+    // have an opinion as to what this binding should be and you should consult other bindings by
+    // priority to determine the valid value.
+    // This is extracted into a single function so that we have a single place to control this.
+    return value !== undefined;
 }
 /**
- * Whether or not the style/class binding being applied was executed within a host bindings
- * function.
+ * Sanitizes or adds suffix to the value.
+ *
+ * If value is `null`/`undefined` no suffix is added
+ * @param {?} value
+ * @param {?} suffixOrSanitizer
  * @return {?}
  */
-function isHostStyling() {
-    return isHostStylingActive(getActiveDirectiveId());
+function normalizeAndApplySuffixOrSanitizer(value, suffixOrSanitizer) {
+    if (value == null /** || value === undefined */) {
+        // do nothing
+    }
+    else if (typeof suffixOrSanitizer === 'function') {
+        // sanitize the value.
+        value = suffixOrSanitizer(value);
+    }
+    else if (typeof suffixOrSanitizer === 'string') {
+        value = value + suffixOrSanitizer;
+    }
+    else if (typeof value === 'object') {
+        value = stringify(unwrapSafeValue(value));
+    }
+    return value;
 }
 /**
- * @param {?} tNode
- * @param {?} hostBindingsMode
- * @param {?} isClassBased
+ * Tests if the `TNode` has input shadow.
+ *
+ * An input shadow is when a directive steals (shadows) the input by using `\@Input('style')` or
+ * `\@Input('class')` as input.
+ *
+ * @param {?} tNode `TNode` which we would like to see if it has shadow.
+ * @param {?} isClassBased `true` if `class` (`false` if `style`)
  * @return {?}
  */
-function patchHostStylingFlag(tNode, hostBindingsMode, isClassBased) {
-    /** @type {?} */
-    const flag = hostBindingsMode ?
-        isClassBased ? 4096 /* hasHostClassBindings */ : 131072 /* hasHostStyleBindings */ :
-        isClassBased ? 2048 /* hasTemplateClassBindings */ : 65536 /* hasTemplateStyleBindings */;
-    patchConfig(tNode, flag);
+export function hasStylingInputShadow(tNode, isClassBased) {
+    return (tNode.flags & (isClassBased ? 16 /* hasClassInput */ : 32 /* hasStyleInput */)) !== 0;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/styling.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 {SafeValue} from '../../sanitization/bypass';\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {throwErrorIfNoChangesMode} from '../errors';\nimport {setInputsForProperty} from '../instructions/shared';\nimport {AttributeMarker, TAttributes, TNode, TNodeFlags, TNodeType} from '../interfaces/node';\nimport {RElement} from '../interfaces/renderer';\nimport {StylingMapArray, StylingMapArrayIndex, TStylingContext} from '../interfaces/styling';\nimport {isDirectiveHost} from '../interfaces/type_checks';\nimport {LView, RENDERER, TVIEW} from '../interfaces/view';\nimport {getActiveDirectiveId, getCheckNoChangesMode, getCurrentStyleSanitizer, getLView, getSelectedIndex, incrementBindingIndex, nextBindingIndex, resetCurrentStyleSanitizer, setCurrentStyleSanitizer, setElementExitFn} from '../state';\nimport {applyStylingMapDirectly, applyStylingValueDirectly, flushStyling, setClass, setStyle, updateClassViaContext, updateStyleViaContext} from '../styling/bindings';\nimport {activateStylingMapFeature} from '../styling/map_based_bindings';\nimport {attachStylingDebugObject} from '../styling/styling_debug';\nimport {NO_CHANGE} from '../tokens';\nimport {renderStringify} from '../util/misc_utils';\nimport {addItemToStylingMap, allocStylingMapArray, allocTStylingContext, allowDirectStyling, concatString, forceClassesAsString, forceStylesAsString, getInitialStylingValue, getStylingMapArray, getValue, hasClassInput, hasStyleInput, hasValueChanged, hasValueChangedUnwrapSafeValue, isHostStylingActive, isStylingContext, isStylingValueDefined, normalizeIntoStylingMap, patchConfig, selectClassBasedInputName, setValue, stylingMapToString} from '../util/styling_utils';\nimport {getNativeByTNode, getTNode} from '../util/view_utils';\n\n\n\n/**\n * --------\n *\n * This file contains the core logic for how styling instructions are processed in Angular.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n\n/**\n * Sets the current style sanitizer function which will then be used\n * within all follow-up prop and map-based style binding instructions\n * for the given element.\n *\n * Note that once styling has been applied to the element (i.e. once\n * `advance(n)` is executed or the hostBindings/template function exits)\n * then the active `sanitizerFn` will be set to `null`. This means that\n * once styling is applied to another element then a another call to\n * `styleSanitizer` will need to be made.\n *\n * @param sanitizerFn The sanitization function that will be used to\n *       process style prop/value entries.\n *\n * @codeGenApi\n */\nexport function ɵɵstyleSanitizer(sanitizer: StyleSanitizeFn | null): void {\n  setCurrentStyleSanitizer(sanitizer);\n}\n\n/**\n * Update a style binding on an element with the provided value.\n *\n * If the style value is falsy then it will be removed from the element\n * (or assigned a different value depending if there are any styles placed\n * on the element with `styleMap` or any static styles that are\n * present from when the element was created with `styling`).\n *\n * Note that the styling element is updated as part of `stylingApply`.\n *\n * @param prop A valid CSS property.\n * @param value New value to write (`null` or an empty string to remove).\n * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.\n *        Note that when a suffix is provided then the underlying sanitizer will\n *        be ignored.\n *\n * Note that this will apply the provided style value to the host element if this function is called\n * within a host binding function.\n *\n * @codeGenApi\n */\nexport function ɵɵstyleProp(\n    prop: string, value: string | number | SafeValue | null,\n    suffix?: string | null): typeof ɵɵstyleProp {\n  stylePropInternal(getSelectedIndex(), prop, value, suffix);\n  return ɵɵstyleProp;\n}\n\n/**\n * Internal function for applying a single style to an element.\n *\n * The reason why this function has been separated from `ɵɵstyleProp` is because\n * it is also called from `ɵɵstylePropInterpolate`.\n */\nexport function stylePropInternal(\n    elementIndex: number, prop: string, value: string | number | SafeValue | null,\n    suffix?: string | null | undefined): void {\n  // if a value is interpolated then it may render a `NO_CHANGE` value.\n  // in this case we do not need to do anything, but the binding index\n  // still needs to be incremented because all styling binding values\n  // are stored inside of the lView.\n  const bindingIndex = nextBindingIndex();\n  const lView = getLView();\n  const tNode = getTNode(elementIndex, lView);\n  const firstUpdatePass = lView[TVIEW].firstUpdatePass;\n\n  // we check for this in the instruction code so that the context can be notified\n  // about prop or map bindings so that the direct apply check can decide earlier\n  // if it allows for context resolution to be bypassed.\n  if (firstUpdatePass) {\n    patchConfig(tNode, TNodeFlags.hasStylePropBindings);\n    patchHostStylingFlag(tNode, isHostStyling(), false);\n  }\n\n  const updated = stylingProp(\n      tNode, firstUpdatePass, lView, bindingIndex, prop, resolveStylePropValue(value, suffix),\n      false);\n  if (ngDevMode) {\n    ngDevMode.styleProp++;\n    if (updated) {\n      ngDevMode.stylePropCacheMiss++;\n    }\n  }\n}\n\n/**\n * Update a class binding on an element with the provided value.\n *\n * This instruction is meant to handle the `[class.foo]=\"exp\"` case and,\n * therefore, the class binding itself must already be allocated using\n * `styling` within the creation block.\n *\n * @param prop A valid CSS class (only one).\n * @param value A true/false value which will turn the class on or off.\n *\n * Note that this will apply the provided class value to the host element if this function\n * is called within a host binding function.\n *\n * @codeGenApi\n */\nexport function ɵɵclassProp(className: string, value: boolean | null): typeof ɵɵclassProp {\n  // if a value is interpolated then it may render a `NO_CHANGE` value.\n  // in this case we do not need to do anything, but the binding index\n  // still needs to be incremented because all styling binding values\n  // are stored inside of the lView.\n  const bindingIndex = nextBindingIndex();\n  const lView = getLView();\n  const elementIndex = getSelectedIndex();\n  const tNode = getTNode(elementIndex, lView);\n  const firstUpdatePass = lView[TVIEW].firstUpdatePass;\n\n  // we check for this in the instruction code so that the context can be notified\n  // about prop or map bindings so that the direct apply check can decide earlier\n  // if it allows for context resolution to be bypassed.\n  if (firstUpdatePass) {\n    patchConfig(tNode, TNodeFlags.hasClassPropBindings);\n    patchHostStylingFlag(tNode, isHostStyling(), true);\n  }\n\n  const updated = stylingProp(tNode, firstUpdatePass, lView, bindingIndex, className, value, true);\n  if (ngDevMode) {\n    ngDevMode.classProp++;\n    if (updated) {\n      ngDevMode.classPropCacheMiss++;\n    }\n  }\n  return ɵɵclassProp;\n}\n\n/**\n * Shared function used to update a prop-based styling binding for an element.\n *\n * Depending on the state of the `tNode.styles` styles context, the style/prop\n * value may be applied directly to the element instead of being processed\n * through the context. The reason why this occurs is for performance and fully\n * depends on the state of the context (i.e. whether or not there are duplicate\n * bindings or whether or not there are map-based bindings and property bindings\n * present together).\n */\nfunction stylingProp(\n    tNode: TNode, firstUpdatePass: boolean, lView: LView, bindingIndex: number, prop: string,\n    value: boolean | number | SafeValue | string | null | undefined | NO_CHANGE,\n    isClassBased: boolean): boolean {\n  let updated = false;\n\n  const native = getNativeByTNode(tNode, lView) as RElement;\n  const context = isClassBased ? getClassesContext(tNode) : getStylesContext(tNode);\n  const sanitizer = isClassBased ? null : getCurrentStyleSanitizer();\n\n  // [style.prop] and [class.name] bindings do not use `bind()` and will\n  // therefore manage accessing and updating the new value in the lView directly.\n  // For this reason, the checkNoChanges situation must also be handled here\n  // as well.\n  if (ngDevMode && getCheckNoChangesMode()) {\n    const oldValue = getValue(lView, bindingIndex);\n    if (hasValueChangedUnwrapSafeValue(oldValue, value)) {\n      throwErrorIfNoChangesMode(false, oldValue, value);\n    }\n  }\n\n  // Direct Apply Case: bypass context resolution and apply the\n  // style/class value directly to the element\n  if (allowDirectStyling(tNode, isClassBased, firstUpdatePass)) {\n    const sanitizerToUse = isClassBased ? null : sanitizer;\n    const renderer = getRenderer(tNode, lView);\n    updated = applyStylingValueDirectly(\n        renderer, context, tNode, native, lView, bindingIndex, prop, value, isClassBased,\n        sanitizerToUse);\n\n    if (sanitizerToUse) {\n      // it's important we remove the current style sanitizer once the\n      // element exits, otherwise it will be used by the next styling\n      // instructions for the next element.\n      setElementExitFn(stylingApply);\n    }\n  } else {\n    // Context Resolution (or first update) Case: save the value\n    // and defer to the context to flush and apply the style/class binding\n    // value to the element.\n    const directiveIndex = getActiveDirectiveId();\n    if (isClassBased) {\n      updated = updateClassViaContext(\n          context, tNode, lView, native, directiveIndex, prop, bindingIndex,\n          value as string | boolean | null, false, firstUpdatePass);\n    } else {\n      updated = updateStyleViaContext(\n          context, tNode, lView, native, directiveIndex, prop, bindingIndex,\n          value as string | SafeValue | null, sanitizer, false, firstUpdatePass);\n    }\n\n    setElementExitFn(stylingApply);\n  }\n\n  return updated;\n}\n\n/**\n * Update style bindings using an object literal on an element.\n *\n * This instruction is meant to apply styling via the `[style]=\"exp\"` template bindings.\n * When styles are applied to the element they will then be updated with respect to\n * any styles/classes set via `styleProp`. If any styles are set to falsy\n * then they will be removed from the element.\n *\n * Note that the styling instruction will not be applied until `stylingApply` is called.\n *\n * @param styles A key/value style map of the styles that will be applied to the given element.\n *        Any missing styles (that have already been applied to the element beforehand) will be\n *        removed (unset) from the element's styling.\n *\n * Note that this will apply the provided styleMap value to the host element if this function\n * is called within a host binding.\n *\n * @codeGenApi\n */\nexport function ɵɵstyleMap(styles: {[styleName: string]: any} | NO_CHANGE | null): void {\n  const index = getSelectedIndex();\n  const lView = getLView();\n  const tNode = getTNode(index, lView);\n  const firstUpdatePass = lView[TVIEW].firstUpdatePass;\n  const context = getStylesContext(tNode);\n  const hasDirectiveInput = hasStyleInput(tNode);\n\n  // if a value is interpolated then it may render a `NO_CHANGE` value.\n  // in this case we do not need to do anything, but the binding index\n  // still needs to be incremented because all styling binding values\n  // are stored inside of the lView.\n  const bindingIndex = incrementBindingIndex(2);\n  const hostBindingsMode = isHostStyling();\n\n  // inputs are only evaluated from a template binding into a directive, therefore,\n  // there should not be a situation where a directive host bindings function\n  // evaluates the inputs (this should only happen in the template function)\n  if (!hostBindingsMode && hasDirectiveInput && styles !== NO_CHANGE) {\n    updateDirectiveInputValue(context, lView, tNode, bindingIndex, styles, false, firstUpdatePass);\n    styles = NO_CHANGE;\n  }\n\n  // we check for this in the instruction code so that the context can be notified\n  // about prop or map bindings so that the direct apply check can decide earlier\n  // if it allows for context resolution to be bypassed.\n  if (firstUpdatePass) {\n    patchConfig(tNode, TNodeFlags.hasStyleMapBindings);\n    patchHostStylingFlag(tNode, isHostStyling(), false);\n  }\n\n  stylingMap(\n      context, tNode, firstUpdatePass, lView, bindingIndex, styles, false, hasDirectiveInput);\n}\n\n/**\n * Update class bindings using an object literal or class-string on an element.\n *\n * This instruction is meant to apply styling via the `[class]=\"exp\"` template bindings.\n * When classes are applied to the element they will then be updated with\n * respect to any styles/classes set via `classProp`. If any\n * classes are set to falsy then they will be removed from the element.\n *\n * Note that the styling instruction will not be applied until `stylingApply` is called.\n * Note that this will the provided classMap value to the host element if this function is called\n * within a host binding.\n *\n * @param classes A key/value map or string of CSS classes that will be added to the\n *        given element. Any missing classes (that have already been applied to the element\n *        beforehand) will be removed (unset) from the element's list of CSS classes.\n *\n * @codeGenApi\n */\nexport function ɵɵclassMap(classes: {[className: string]: any} | NO_CHANGE | string | null): void {\n  classMapInternal(getSelectedIndex(), classes);\n}\n\n/**\n * Internal function for applying a class string or key/value map of classes to an element.\n *\n * The reason why this function has been separated from `ɵɵclassMap` is because\n * it is also called from `ɵɵclassMapInterpolate`.\n */\nexport function classMapInternal(\n    elementIndex: number, classes: {[className: string]: any} | NO_CHANGE | string | null): void {\n  const lView = getLView();\n  const tNode = getTNode(elementIndex, lView);\n  const firstUpdatePass = lView[TVIEW].firstUpdatePass;\n  const context = getClassesContext(tNode);\n  const hasDirectiveInput = hasClassInput(tNode);\n\n  // if a value is interpolated then it may render a `NO_CHANGE` value.\n  // in this case we do not need to do anything, but the binding index\n  // still needs to be incremented because all styling binding values\n  // are stored inside of the lView.\n  const bindingIndex = incrementBindingIndex(2);\n  const hostBindingsMode = isHostStyling();\n\n  // inputs are only evaluated from a template binding into a directive, therefore,\n  // there should not be a situation where a directive host bindings function\n  // evaluates the inputs (this should only happen in the template function)\n  if (!hostBindingsMode && hasDirectiveInput && classes !== NO_CHANGE) {\n    updateDirectiveInputValue(context, lView, tNode, bindingIndex, classes, true, firstUpdatePass);\n    classes = NO_CHANGE;\n  }\n\n  // we check for this in the instruction code so that the context can be notified\n  // about prop or map bindings so that the direct apply check can decide earlier\n  // if it allows for context resolution to be bypassed.\n  if (firstUpdatePass) {\n    patchConfig(tNode, TNodeFlags.hasClassMapBindings);\n    patchHostStylingFlag(tNode, isHostStyling(), true);\n  }\n\n  stylingMap(\n      context, tNode, firstUpdatePass, lView, bindingIndex, classes, true, hasDirectiveInput);\n}\n\n/**\n * Shared function used to update a map-based styling binding for an element.\n *\n * When this function is called it will activate support for `[style]` and\n * `[class]` bindings in Angular.\n */\nfunction stylingMap(\n    context: TStylingContext, tNode: TNode, firstUpdatePass: boolean, lView: LView,\n    bindingIndex: number, value: {[key: string]: any} | string | null, isClassBased: boolean,\n    hasDirectiveInput: boolean): void {\n  const directiveIndex = getActiveDirectiveId();\n  const native = getNativeByTNode(tNode, lView) as RElement;\n  const oldValue = getValue(lView, bindingIndex);\n  const sanitizer = getCurrentStyleSanitizer();\n  const valueHasChanged = hasValueChanged(oldValue, value);\n\n  // [style] and [class] bindings do not use `bind()` and will therefore\n  // manage accessing and updating the new value in the lView directly.\n  // For this reason, the checkNoChanges situation must also be handled here\n  // as well.\n  if (ngDevMode && valueHasChanged && getCheckNoChangesMode()) {\n    throwErrorIfNoChangesMode(false, oldValue, value);\n  }\n\n  // Direct Apply Case: bypass context resolution and apply the\n  // style/class map values directly to the element\n  if (allowDirectStyling(tNode, isClassBased, firstUpdatePass)) {\n    const sanitizerToUse = isClassBased ? null : sanitizer;\n    const renderer = getRenderer(tNode, lView);\n    applyStylingMapDirectly(\n        renderer, context, tNode, native, lView, bindingIndex, value, isClassBased, sanitizerToUse,\n        valueHasChanged, hasDirectiveInput);\n    if (sanitizerToUse) {\n      // it's important we remove the current style sanitizer once the\n      // element exits, otherwise it will be used by the next styling\n      // instructions for the next element.\n      setElementExitFn(stylingApply);\n    }\n  } else {\n    const stylingMapArr =\n        value === NO_CHANGE ? NO_CHANGE : normalizeIntoStylingMap(oldValue, value, !isClassBased);\n\n    activateStylingMapFeature();\n\n    // Context Resolution (or first update) Case: save the map value\n    // and defer to the context to flush and apply the style/class binding\n    // value to the element.\n    if (isClassBased) {\n      updateClassViaContext(\n          context, tNode, lView, native, directiveIndex, null, bindingIndex, stylingMapArr,\n          valueHasChanged, firstUpdatePass);\n    } else {\n      updateStyleViaContext(\n          context, tNode, lView, native, directiveIndex, null, bindingIndex, stylingMapArr,\n          sanitizer, valueHasChanged, firstUpdatePass);\n    }\n\n    setElementExitFn(stylingApply);\n  }\n\n  if (ngDevMode) {\n    isClassBased ? ngDevMode.classMap : ngDevMode.styleMap++;\n    if (valueHasChanged) {\n      isClassBased ? ngDevMode.classMapCacheMiss : ngDevMode.styleMapCacheMiss++;\n    }\n  }\n}\n\n/**\n * Writes a value to a directive's `style` or `class` input binding (if it has changed).\n *\n * If a directive has a `@Input` binding that is set on `style` or `class` then that value\n * will take priority over the underlying style/class styling bindings. This value will\n * be updated for the binding each time during change detection.\n *\n * When this occurs this function will attempt to write the value to the input binding\n * depending on the following situations:\n *\n * - If `oldValue !== newValue`\n * - If `newValue` is `null` (but this is skipped if it is during the first update pass)\n */\nfunction updateDirectiveInputValue(\n    context: TStylingContext, lView: LView, tNode: TNode, bindingIndex: number, newValue: any,\n    isClassBased: boolean, firstUpdatePass: boolean): void {\n  const oldValue = getValue(lView, bindingIndex);\n  if (hasValueChanged(oldValue, newValue)) {\n    // even if the value has changed we may not want to emit it to the\n    // directive input(s) in the event that it is falsy during the\n    // first update pass.\n    if (isStylingValueDefined(newValue) || !firstUpdatePass) {\n      const inputName: string = isClassBased ? selectClassBasedInputName(tNode.inputs !) : 'style';\n      const inputs = tNode.inputs ![inputName] !;\n      const initialValue = getInitialStylingValue(context);\n      const value = normalizeStylingDirectiveInputValue(initialValue, newValue, isClassBased);\n      setInputsForProperty(lView, inputs, inputName, value);\n      setElementExitFn(stylingApply);\n    }\n    setValue(lView, bindingIndex, newValue);\n  }\n}\n\n/**\n * Returns the appropriate directive input value for `style` or `class`.\n *\n * Earlier versions of Angular expect a binding value to be passed into directive code\n * exactly as it is unless there is a static value present (in which case both values\n * will be stringified and concatenated).\n */\nfunction normalizeStylingDirectiveInputValue(\n    initialValue: string, bindingValue: string | {[key: string]: any} | null,\n    isClassBased: boolean) {\n  let value = bindingValue;\n\n  // we only concat values if there is an initial value, otherwise we return the value as is.\n  // Note that this is to satisfy backwards-compatibility in Angular.\n  if (initialValue.length) {\n    if (isClassBased) {\n      value = concatString(initialValue, forceClassesAsString(bindingValue));\n    } else {\n      value = concatString(initialValue, forceStylesAsString(bindingValue, true), ';');\n    }\n  }\n  return value;\n}\n\n/**\n * Flushes all styling code to the element.\n *\n * This function is designed to be scheduled from any of the four styling instructions\n * in this file. When called it will flush all style and class bindings to the element\n * via the context resolution algorithm.\n */\nfunction stylingApply(): void {\n  const lView = getLView();\n  const tView = lView[TVIEW];\n  const elementIndex = getSelectedIndex();\n  const tNode = getTNode(elementIndex, lView);\n  const native = getNativeByTNode(tNode, lView) as RElement;\n  const directiveIndex = getActiveDirectiveId();\n  const renderer = getRenderer(tNode, lView);\n  const sanitizer = getCurrentStyleSanitizer();\n  const classesContext = isStylingContext(tNode.classes) ? tNode.classes as TStylingContext : null;\n  const stylesContext = isStylingContext(tNode.styles) ? tNode.styles as TStylingContext : null;\n  flushStyling(\n      renderer, lView, tNode, classesContext, stylesContext, native, directiveIndex, sanitizer,\n      tView.firstUpdatePass);\n  resetCurrentStyleSanitizer();\n}\n\nfunction getRenderer(tNode: TNode, lView: LView) {\n  return tNode.type === TNodeType.Element ? lView[RENDERER] : null;\n}\n\n/**\n * Searches and assigns provided all static style/class entries (found in the `attrs` value)\n * and registers them in their respective styling contexts.\n */\nexport function registerInitialStylingOnTNode(\n    tNode: TNode, attrs: TAttributes, startIndex: number): boolean {\n  let hasAdditionalInitialStyling = false;\n  let styles = getStylingMapArray(tNode.styles);\n  let classes = getStylingMapArray(tNode.classes);\n  let mode = -1;\n  for (let i = startIndex; i < attrs.length; i++) {\n    const attr = attrs[i] as string;\n    if (typeof attr == 'number') {\n      mode = attr;\n    } else if (mode == AttributeMarker.Classes) {\n      classes = classes || allocStylingMapArray(null);\n      addItemToStylingMap(classes, attr, true);\n      hasAdditionalInitialStyling = true;\n    } else if (mode == AttributeMarker.Styles) {\n      const value = attrs[++i] as string | null;\n      styles = styles || allocStylingMapArray(null);\n      addItemToStylingMap(styles, attr, value);\n      hasAdditionalInitialStyling = true;\n    }\n  }\n\n  if (classes && classes.length > StylingMapArrayIndex.ValuesStartPosition) {\n    if (!tNode.classes) {\n      tNode.classes = classes;\n    }\n    updateRawValueOnContext(tNode.classes, stylingMapToString(classes, true));\n  }\n\n  if (styles && styles.length > StylingMapArrayIndex.ValuesStartPosition) {\n    if (!tNode.styles) {\n      tNode.styles = styles;\n    }\n    updateRawValueOnContext(tNode.styles, stylingMapToString(styles, false));\n  }\n\n  if (hasAdditionalInitialStyling) {\n    tNode.flags |= TNodeFlags.hasInitialStyling;\n  }\n\n  return hasAdditionalInitialStyling;\n}\n\nfunction updateRawValueOnContext(context: TStylingContext | StylingMapArray, value: string) {\n  const stylingMapArr = getStylingMapArray(context) !;\n  stylingMapArr[StylingMapArrayIndex.RawValuePosition] = value;\n}\n\nfunction getStylesContext(tNode: TNode): TStylingContext {\n  return getContext(tNode, false);\n}\n\nfunction getClassesContext(tNode: TNode): TStylingContext {\n  return getContext(tNode, true);\n}\n\n/**\n * Returns/instantiates a styling context from/to a `tNode` instance.\n */\nfunction getContext(tNode: TNode, isClassBased: boolean): TStylingContext {\n  let context = isClassBased ? tNode.classes : tNode.styles;\n  if (!isStylingContext(context)) {\n    const hasDirectives = isDirectiveHost(tNode);\n    context = allocTStylingContext(context as StylingMapArray | null, hasDirectives);\n    if (ngDevMode) {\n      attachStylingDebugObject(context as TStylingContext, tNode, isClassBased);\n    }\n\n    if (isClassBased) {\n      tNode.classes = context;\n    } else {\n      tNode.styles = context;\n    }\n  }\n  return context as TStylingContext;\n}\n\nfunction resolveStylePropValue(\n    value: string | number | SafeValue | null | NO_CHANGE,\n    suffix: string | null | undefined): string|SafeValue|null|undefined|NO_CHANGE {\n  if (value === NO_CHANGE) return value;\n\n  let resolvedValue: string|null = null;\n  if (isStylingValueDefined(value)) {\n    if (suffix) {\n      // when a suffix is applied then it will bypass\n      // sanitization entirely (b/c a new string is created)\n      resolvedValue = renderStringify(value) + suffix;\n    } else {\n      // sanitization happens by dealing with a string value\n      // this means that the string value will be passed through\n      // into the style rendering later (which is where the value\n      // will be sanitized before it is applied)\n      resolvedValue = value as any as string;\n    }\n  }\n  return resolvedValue;\n}\n\n/**\n * Whether or not the style/class binding being applied was executed within a host bindings\n * function.\n */\nfunction isHostStyling(): boolean {\n  return isHostStylingActive(getActiveDirectiveId());\n}\n\nfunction patchHostStylingFlag(tNode: TNode, hostBindingsMode: boolean, isClassBased: boolean) {\n  const flag = hostBindingsMode ?\n      isClassBased ? TNodeFlags.hasHostClassBindings : TNodeFlags.hasHostStyleBindings :\n      isClassBased ? TNodeFlags.hasTemplateClassBindings : TNodeFlags.hasTemplateStyleBindings;\n  patchConfig(tNode, flag);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/styling.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\n\nimport {SafeValue, unwrapSafeValue} from '../../sanitization/bypass';\nimport {stylePropNeedsSanitization, ɵɵsanitizeStyle} from '../../sanitization/sanitization';\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {KeyValueArray, keyValueArrayGet, keyValueArraySet} from '../../util/array_utils';\nimport {assertDefined, assertEqual, assertLessThan, assertNotEqual, throwError} from '../../util/assert';\nimport {EMPTY_ARRAY} from '../../util/empty';\nimport {concatStringsWithSpace, stringify} from '../../util/stringify';\nimport {assertFirstUpdatePass} from '../assert';\nimport {bindingUpdated} from '../bindings';\nimport {DirectiveDef} from '../interfaces/definition';\nimport {AttributeMarker, TAttributes, TNode, TNodeFlags, TNodeType} from '../interfaces/node';\nimport {RElement, Renderer3} from '../interfaces/renderer';\nimport {SanitizerFn} from '../interfaces/sanitization';\nimport {TStylingKey, TStylingRange, getTStylingRangeNext, getTStylingRangeNextDuplicate, getTStylingRangePrev, getTStylingRangePrevDuplicate} from '../interfaces/styling';\nimport {HEADER_OFFSET, LView, RENDERER, TData, TView} from '../interfaces/view';\nimport {applyStyling} from '../node_manipulation';\nimport {getCurrentDirectiveIndex, getCurrentStyleSanitizer, getLView, getSelectedIndex, getTView, incrementBindingIndex, setCurrentStyleSanitizer} from '../state';\nimport {insertTStylingBinding} from '../styling/style_binding_list';\nimport {getLastParsedKey, getLastParsedValue, parseClassName, parseClassNameNext, parseStyle, parseStyleNext} from '../styling/styling_parser';\nimport {NO_CHANGE} from '../tokens';\nimport {getNativeByIndex} from '../util/view_utils';\nimport {setDirectiveInputsWhichShadowsStyling} from './property';\n\n\n/**\n * Sets the current style sanitizer function which will then be used\n * within all follow-up prop and map-based style binding instructions\n * for the given element.\n *\n * Note that once styling has been applied to the element (i.e. once\n * `advance(n)` is executed or the hostBindings/template function exits)\n * then the active `sanitizerFn` will be set to `null`. This means that\n * once styling is applied to another element then a another call to\n * `styleSanitizer` will need to be made.\n *\n * @param sanitizerFn The sanitization function that will be used to\n *       process style prop/value entries.\n *\n * @codeGenApi\n */\nexport function ɵɵstyleSanitizer(sanitizer: StyleSanitizeFn | null): void {\n  setCurrentStyleSanitizer(sanitizer);\n}\n\n/**\n * Update a style binding on an element with the provided value.\n *\n * If the style value is falsy then it will be removed from the element\n * (or assigned a different value depending if there are any styles placed\n * on the element with `styleMap` or any static styles that are\n * present from when the element was created with `styling`).\n *\n * Note that the styling element is updated as part of `stylingApply`.\n *\n * @param prop A valid CSS property.\n * @param value New value to write (`null` or an empty string to remove).\n * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.\n *        Note that when a suffix is provided then the underlying sanitizer will\n *        be ignored.\n *\n * Note that this will apply the provided style value to the host element if this function is called\n * within a host binding function.\n *\n * @codeGenApi\n */\nexport function ɵɵstyleProp(\n    prop: string, value: string | number | SafeValue | undefined | null,\n    suffix?: string | null): typeof ɵɵstyleProp {\n  checkStylingProperty(prop, value, suffix, false);\n  return ɵɵstyleProp;\n}\n\n/**\n * Update a class binding on an element with the provided value.\n *\n * This instruction is meant to handle the `[class.foo]=\"exp\"` case and,\n * therefore, the class binding itself must already be allocated using\n * `styling` within the creation block.\n *\n * @param prop A valid CSS class (only one).\n * @param value A true/false value which will turn the class on or off.\n *\n * Note that this will apply the provided class value to the host element if this function\n * is called within a host binding function.\n *\n * @codeGenApi\n */\nexport function ɵɵclassProp(\n    className: string, value: boolean | undefined | null): typeof ɵɵclassProp {\n  checkStylingProperty(className, value, null, true);\n  return ɵɵclassProp;\n}\n\n\n/**\n * Update style bindings using an object literal on an element.\n *\n * This instruction is meant to apply styling via the `[style]=\"exp\"` template bindings.\n * When styles are applied to the element they will then be updated with respect to\n * any styles/classes set via `styleProp`. If any styles are set to falsy\n * then they will be removed from the element.\n *\n * Note that the styling instruction will not be applied until `stylingApply` is called.\n *\n * @param styles A key/value style map of the styles that will be applied to the given element.\n *        Any missing styles (that have already been applied to the element beforehand) will be\n *        removed (unset) from the element's styling.\n *\n * Note that this will apply the provided styleMap value to the host element if this function\n * is called within a host binding.\n *\n * @codeGenApi\n */\nexport function ɵɵstyleMap(\n    styles: {[styleName: string]: any} | Map<string, string|number|null|undefined>| string |\n    undefined | null): void {\n  checkStylingMap(styleKeyValueArraySet, styleStringParser, styles, false);\n}\n\n\n/**\n * Parse text as style and add values to KeyValueArray.\n *\n * This code is pulled out to a separate function so that it can be tree shaken away if it is not\n * needed. It is only referenced from `ɵɵstyleMap`.\n *\n * @param keyValueArray KeyValueArray to add parsed values to.\n * @param text text to parse.\n */\nexport function styleStringParser(keyValueArray: KeyValueArray<any>, text: string): void {\n  for (let i = parseStyle(text); i >= 0; i = parseStyleNext(text, i)) {\n    styleKeyValueArraySet(keyValueArray, getLastParsedKey(text), getLastParsedValue(text));\n  }\n}\n\n\n/**\n * Update class bindings using an object literal or class-string on an element.\n *\n * This instruction is meant to apply styling via the `[class]=\"exp\"` template bindings.\n * When classes are applied to the element they will then be updated with\n * respect to any styles/classes set via `classProp`. If any\n * classes are set to falsy then they will be removed from the element.\n *\n * Note that the styling instruction will not be applied until `stylingApply` is called.\n * Note that this will the provided classMap value to the host element if this function is called\n * within a host binding.\n *\n * @param classes A key/value map or string of CSS classes that will be added to the\n *        given element. Any missing classes (that have already been applied to the element\n *        beforehand) will be removed (unset) from the element's list of CSS classes.\n *\n * @codeGenApi\n */\nexport function ɵɵclassMap(\n    classes: {[className: string]: boolean | undefined | null} |\n    Map<string, boolean|undefined|null>| Set<string>| string[] | string | undefined | null): void {\n  checkStylingMap(keyValueArraySet, classStringParser, classes, true);\n}\n\n/**\n * Parse text as class and add values to KeyValueArray.\n *\n * This code is pulled out to a separate function so that it can be tree shaken away if it is not\n * needed. It is only referenced from `ɵɵclassMap`.\n *\n * @param keyValueArray KeyValueArray to add parsed values to.\n * @param text text to parse.\n */\nexport function classStringParser(keyValueArray: KeyValueArray<any>, text: string): void {\n  for (let i = parseClassName(text); i >= 0; i = parseClassNameNext(text, i)) {\n    keyValueArraySet(keyValueArray, getLastParsedKey(text), true);\n  }\n}\n\n/**\n * Common code between `ɵɵclassProp` and `ɵɵstyleProp`.\n *\n * @param prop property name.\n * @param value binding value.\n * @param suffixOrSanitizer suffix or sanitization function\n * @param isClassBased `true` if `class` change (`false` if `style`)\n */\nexport function checkStylingProperty(\n    prop: string, value: any | NO_CHANGE,\n    suffixOrSanitizer: SanitizerFn | string | undefined | null, isClassBased: boolean): void {\n  const lView = getLView();\n  const tView = getTView();\n  // Styling instructions use 2 slots per binding.\n  // 1. one for the value / TStylingKey\n  // 2. one for the intermittent-value / TStylingRange\n  const bindingIndex = incrementBindingIndex(2);\n  if (tView.firstUpdatePass) {\n    stylingFirstUpdatePass(tView, prop, bindingIndex, isClassBased);\n  }\n  if (value !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value)) {\n    // This is a work around. Once PR#34480 lands the sanitizer is passed explicitly and this line\n    // can be removed.\n    let styleSanitizer: StyleSanitizeFn|null;\n    if (suffixOrSanitizer == null) {\n      if (styleSanitizer = getCurrentStyleSanitizer()) {\n        suffixOrSanitizer = styleSanitizer as any;\n      }\n    }\n    const tNode = tView.data[getSelectedIndex() + HEADER_OFFSET] as TNode;\n    updateStyling(\n        tView, tNode, lView, lView[RENDERER], prop,\n        lView[bindingIndex + 1] = normalizeAndApplySuffixOrSanitizer(value, suffixOrSanitizer),\n        isClassBased, bindingIndex);\n  }\n}\n\n/**\n * Common code between `ɵɵclassMap` and `ɵɵstyleMap`.\n *\n * @param keyValueArraySet (See `keyValueArraySet` in \"util/array_utils\") Gets passed in as a\n * function so that\n *        `style` can pass in version which does sanitization. This is done for tree shaking\n *        purposes.\n * @param stringParser Parser used to parse `value` if `string`. (Passed in as `style` and `class`\n *        have different parsers.)\n * @param value bound value from application\n * @param isClassBased `true` if `class` change (`false` if `style`)\n */\nexport function checkStylingMap(\n    keyValueArraySet: (keyValueArray: KeyValueArray<any>, key: string, value: any) => void,\n    stringParser: (styleKeyValueArray: KeyValueArray<any>, text: string) => void,\n    value: any|NO_CHANGE, isClassBased: boolean): void {\n  const tView = getTView();\n  const bindingIndex = incrementBindingIndex(2);\n  if (tView.firstUpdatePass) {\n    stylingFirstUpdatePass(tView, null, bindingIndex, isClassBased);\n  }\n  const lView = getLView();\n  if (value !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value)) {\n    // `getSelectedIndex()` should be here (rather than in instruction) so that it is guarded by the\n    // if so as not to read unnecessarily.\n    const tNode = tView.data[getSelectedIndex() + HEADER_OFFSET] as TNode;\n    if (hasStylingInputShadow(tNode, isClassBased) && !isInHostBindings(tView, bindingIndex)) {\n      if (ngDevMode) {\n        // verify that if we are shadowing then `TData` is appropriately marked so that we skip\n        // processing this binding in styling resolution.\n        const tStylingKey = tView.data[bindingIndex];\n        assertEqual(\n            Array.isArray(tStylingKey) ? tStylingKey[1] : tStylingKey, false,\n            'Styling linked list shadow input should be marked as \\'false\\'');\n      }\n      // VE does not concatenate the static portion like we are doing here.\n      // Instead VE just ignores the static completely if dynamic binding is present.\n      // Because of locality we have already set the static portion because we don't know if there\n      // is a dynamic portion until later. If we would ignore the static portion it would look like\n      // the binding has removed it. This would confuse `[ngStyle]`/`[ngClass]` to do the wrong\n      // thing as it would think that the static portion was removed. For this reason we\n      // concatenate it so that `[ngStyle]`/`[ngClass]`  can continue to work on changed.\n      let staticPrefix = isClassBased ? tNode.classes : tNode.styles;\n      ngDevMode && isClassBased === false && staticPrefix !== null &&\n          assertEqual(\n              staticPrefix.endsWith(';'), true, 'Expecting static portion to end with \\';\\'');\n      if (typeof value === 'string') {\n        value = concatStringsWithSpace(staticPrefix, value as string);\n      }\n      // Given `<div [style] my-dir>` such that `my-dir` has `@Input('style')`.\n      // This takes over the `[style]` binding. (Same for `[class]`)\n      setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value, isClassBased);\n    } else {\n      updateStylingMap(\n          tView, tNode, lView, lView[RENDERER], lView[bindingIndex + 1],\n          lView[bindingIndex + 1] = toStylingKeyValueArray(keyValueArraySet, stringParser, value),\n          isClassBased, bindingIndex);\n    }\n  }\n}\n\n/**\n * Determines when the binding is in `hostBindings` section\n *\n * @param tView Current `TView`\n * @param bindingIndex index of binding which we would like if it is in `hostBindings`\n */\nfunction isInHostBindings(tView: TView, bindingIndex: number): boolean {\n  // All host bindings are placed after the expando section.\n  return bindingIndex >= tView.expandoStartIndex;\n}\n\n/**\n* Collects the necessary information to insert the binding into a linked list of style bindings\n* using `insertTStylingBinding`.\n*\n* @param tView `TView` where the binding linked list will be stored.\n* @param tStylingKey Property/key of the binding.\n* @param bindingIndex Index of binding associated with the `prop`\n* @param isClassBased `true` if `class` change (`false` if `style`)\n*/\nfunction stylingFirstUpdatePass(\n    tView: TView, tStylingKey: TStylingKey, bindingIndex: number, isClassBased: boolean): void {\n  ngDevMode && assertFirstUpdatePass(tView);\n  const tData = tView.data;\n  if (tData[bindingIndex + 1] === null) {\n    // The above check is necessary because we don't clear first update pass until first successful\n    // (no exception) template execution. This prevents the styling instruction from double adding\n    // itself to the list.\n    // `getSelectedIndex()` should be here (rather than in instruction) so that it is guarded by the\n    // if so as not to read unnecessarily.\n    const tNode = tData[getSelectedIndex() + HEADER_OFFSET] as TNode;\n    const isHostBindings = isInHostBindings(tView, bindingIndex);\n    if (hasStylingInputShadow(tNode, isClassBased) && tStylingKey === null && !isHostBindings) {\n      // `tStylingKey === null` implies that we are either `[style]` or `[class]` binding.\n      // If there is a directive which uses `@Input('style')` or `@Input('class')` than\n      // we need to neutralize this binding since that directive is shadowing it.\n      // We turn this into a noop by setting the key to `false`\n      tStylingKey = false;\n    }\n    tStylingKey = wrapInStaticStylingKey(tData, tNode, tStylingKey, isClassBased);\n    insertTStylingBinding(tData, tNode, tStylingKey, bindingIndex, isHostBindings, isClassBased);\n  }\n}\n\n/**\n * Adds static styling information to the binding if applicable.\n *\n * The linked list of styles not only stores the list and keys, but also stores static styling\n * information on some of the keys. This function determines if the key should contain the styling\n * information and computes it.\n *\n * See `TStylingStatic` for more details.\n *\n * @param tData `TData` where the linked list is stored.\n * @param tNode `TNode` for which the styling is being computed.\n * @param stylingKey `TStylingKeyPrimitive` which may need to be wrapped into `TStylingKey`\n * @param isClassBased `true` if `class` (`false` if `style`)\n */\nexport function wrapInStaticStylingKey(\n    tData: TData, tNode: TNode, stylingKey: TStylingKey, isClassBased: boolean): TStylingKey {\n  const hostDirectiveDef = getHostDirectiveDef(tData);\n  let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;\n  if (hostDirectiveDef === null) {\n    // We are in template node.\n    // If template node already had styling instruction then it has already collected the static\n    // styling and there is no need to collect them again. We know that we are the first styling\n    // instruction because the `TNode.*Bindings` points to 0 (nothing has been inserted yet).\n    const isFirstStylingInstructionInTemplate =\n        (isClassBased ? tNode.classBindings : tNode.styleBindings) as any as number === 0;\n    if (isFirstStylingInstructionInTemplate) {\n      // It would be nice to be able to get the statics from `mergeAttrs`, however, at this point\n      // they are already merged and it would not be possible to figure which property belongs where\n      // in the priority.\n      stylingKey = collectStylingFromDirectives(null, tData, tNode, stylingKey, isClassBased);\n      stylingKey = collectStylingFromTAttrs(stylingKey, tNode.attrs, isClassBased);\n      // We know that if we have styling binding in template we can't have residual.\n      residual = null;\n    }\n  } else {\n    // We are in host binding node and there was no binding instruction in template node.\n    // This means that we need to compute the residual.\n    const directiveStylingLast = tNode.directiveStylingLast;\n    const isFirstStylingInstructionInHostBinding =\n        directiveStylingLast === -1 || tData[directiveStylingLast] !== hostDirectiveDef;\n    if (isFirstStylingInstructionInHostBinding) {\n      stylingKey =\n          collectStylingFromDirectives(hostDirectiveDef, tData, tNode, stylingKey, isClassBased);\n      if (residual === null) {\n        // - If `null` than either:\n        //    - Template styling instruction already ran and it has consumed the static\n        //      styling into its `TStylingKey` and so there is no need to update residual. Instead\n        //      we need to update the `TStylingKey` associated with the first template node\n        //      instruction. OR\n        //    - Some other styling instruction ran and determined that there are no residuals\n        let templateStylingKey = getTemplateHeadTStylingKey(tData, tNode, isClassBased);\n        if (templateStylingKey !== undefined && Array.isArray(templateStylingKey)) {\n          // Only recompute if `templateStylingKey` had static values. (If no static value found\n          // then there is nothing to do since this operation can only produce less static keys, not\n          // more.)\n          templateStylingKey = collectStylingFromDirectives(\n              null, tData, tNode, templateStylingKey[1] /* unwrap previous statics */,\n              isClassBased);\n          templateStylingKey =\n              collectStylingFromTAttrs(templateStylingKey, tNode.attrs, isClassBased);\n          setTemplateHeadTStylingKey(tData, tNode, isClassBased, templateStylingKey);\n        }\n      } else {\n        // We only need to recompute residual if it is not `null`.\n        // - If existing residual (implies there was no template styling). This means that some of\n        //   the statics may have moved from the residual to the `stylingKey` and so we have to\n        //   recompute.\n        // - If `undefined` this is the first time we are running.\n        residual = collectResidual(tData, tNode, isClassBased);\n      }\n    }\n  }\n  if (residual !== undefined) {\n    isClassBased ? (tNode.residualClasses = residual) : (tNode.residualStyles = residual);\n  }\n  return stylingKey;\n}\n\n/**\n * Retrieve the `TStylingKey` for the template styling instruction.\n *\n * This is needed since `hostBinding` styling instructions are inserted after the template\n * instruction. While the template instruction needs to update the residual in `TNode` the\n * `hostBinding` instructions need to update the `TStylingKey` of the template instruction because\n * the template instruction is downstream from the `hostBindings` instructions.\n *\n * @param tData `TData` where the linked list is stored.\n * @param tNode `TNode` for which the styling is being computed.\n * @param isClassBased `true` if `class` (`false` if `style`)\n * @return `TStylingKey` if found or `undefined` if not found.\n */\nfunction getTemplateHeadTStylingKey(tData: TData, tNode: TNode, isClassBased: boolean): TStylingKey|\n    undefined {\n  const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;\n  if (getTStylingRangeNext(bindings) === 0) {\n    // There does not seem to be a styling instruction in the `template`.\n    return undefined;\n  }\n  return tData[getTStylingRangePrev(bindings)] as TStylingKey;\n}\n\n/**\n * Update the `TStylingKey` of the first template instruction in `TNode`.\n *\n * Logically `hostBindings` styling instructions are of lower priority than that of the template.\n * However, they execute after the template styling instructions. This means that they get inserted\n * in front of the template styling instructions.\n *\n * If we have a template styling instruction and a new `hostBindings` styling instruction is\n * executed it means that it may need to steal static fields from the template instruction. This\n * method allows us to update the first template instruction `TStylingKey` with a new value.\n *\n * Assume:\n * ```\n * <div my-dir style=\"color: red\" [style.color]=\"tmplExp\"></div>\n *\n * @Directive({\n *   host: {\n *     'style': 'width: 100px',\n *     '[style.color]': 'dirExp',\n *   }\n * })\n * class MyDir {}\n * ```\n *\n * when `[style.color]=\"tmplExp\"` executes it creates this data structure.\n * ```\n *  ['', 'color', 'color', 'red', 'width', '100px'],\n * ```\n *\n * The reason for this is that the template instruction does not know if there are styling\n * instructions and must assume that there are none and must collect all of the static styling.\n * (both\n * `color' and 'width`)\n *\n * When `'[style.color]': 'dirExp',` executes we need to insert a new data into the linked list.\n * ```\n *  ['', 'color', 'width', '100px'],  // newly inserted\n *  ['', 'color', 'color', 'red', 'width', '100px'], // this is wrong\n * ```\n *\n * Notice that the template statics is now wrong as it incorrectly contains `width` so we need to\n * update it like so:\n * ```\n *  ['', 'color', 'width', '100px'],\n *  ['', 'color', 'color', 'red'],    // UPDATE\n * ```\n *\n * @param tData `TData` where the linked list is stored.\n * @param tNode `TNode` for which the styling is being computed.\n * @param isClassBased `true` if `class` (`false` if `style`)\n * @param tStylingKey New `TStylingKey` which is replacing the old one.\n */\nfunction setTemplateHeadTStylingKey(\n    tData: TData, tNode: TNode, isClassBased: boolean, tStylingKey: TStylingKey): void {\n  const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;\n  ngDevMode && assertNotEqual(\n                   getTStylingRangeNext(bindings), 0,\n                   'Expecting to have at least one template styling binding.');\n  tData[getTStylingRangePrev(bindings)] = tStylingKey;\n}\n\n/**\n * Collect all static values after the current `TNode.directiveStylingLast` index.\n *\n * Collect the remaining styling information which has not yet been collected by an existing\n * styling instruction.\n *\n * @param tData `TData` where the `DirectiveDefs` are stored.\n * @param tNode `TNode` which contains the directive range.\n * @param isClassBased `true` if `class` (`false` if `style`)\n */\nfunction collectResidual(tData: TData, tNode: TNode, isClassBased: boolean): KeyValueArray<any>|\n    null {\n  let residual: KeyValueArray<any>|null|undefined = undefined;\n  const directiveEnd = tNode.directiveEnd;\n  ngDevMode &&\n      assertNotEqual(\n          tNode.directiveStylingLast, -1,\n          'By the time this function gets called at least one hostBindings-node styling instruction must have executed.');\n  // We add `1 + tNode.directiveStart` because we need to skip the current directive (as we are\n  // collecting things after the last `hostBindings` directive which had a styling instruction.)\n  for (let i = 1 + tNode.directiveStylingLast; i < directiveEnd; i++) {\n    const attrs = (tData[i] as DirectiveDef<any>).hostAttrs;\n    residual = collectStylingFromTAttrs(residual, attrs, isClassBased) as KeyValueArray<any>| null;\n  }\n  return collectStylingFromTAttrs(residual, tNode.attrs, isClassBased) as KeyValueArray<any>| null;\n}\n\n/**\n * Collect the static styling information with lower priority than `hostDirectiveDef`.\n *\n * (This is opposite of residual styling.)\n *\n * @param hostDirectiveDef `DirectiveDef` for which we want to collect lower priority static\n *        styling. (Or `null` if template styling)\n * @param tData `TData` where the linked list is stored.\n * @param tNode `TNode` for which the styling is being computed.\n * @param stylingKey Existing `TStylingKey` to update or wrap.\n * @param isClassBased `true` if `class` (`false` if `style`)\n */\nfunction collectStylingFromDirectives(\n    hostDirectiveDef: DirectiveDef<any>| null, tData: TData, tNode: TNode, stylingKey: TStylingKey,\n    isClassBased: boolean): TStylingKey {\n  // We need to loop because there can be directives which have `hostAttrs` but don't have\n  // `hostBindings` so this loop catches up to the current directive..\n  let currentDirective: DirectiveDef<any>|null = null;\n  const directiveEnd = tNode.directiveEnd;\n  let directiveStylingLast = tNode.directiveStylingLast;\n  if (directiveStylingLast === -1) {\n    directiveStylingLast = tNode.directiveStart;\n  } else {\n    directiveStylingLast++;\n  }\n  while (directiveStylingLast < directiveEnd) {\n    currentDirective = tData[directiveStylingLast] as DirectiveDef<any>;\n    ngDevMode && assertDefined(currentDirective, 'expected to be defined');\n    stylingKey = collectStylingFromTAttrs(stylingKey, currentDirective.hostAttrs, isClassBased);\n    if (currentDirective === hostDirectiveDef) break;\n    directiveStylingLast++;\n  }\n  if (hostDirectiveDef !== null) {\n    // we only advance the styling cursor if we are collecting data from host bindings.\n    // Template executes before host bindings and so if we would update the index,\n    // host bindings would not get their statics.\n    tNode.directiveStylingLast = directiveStylingLast;\n  }\n  return stylingKey;\n}\n\n/**\n * Convert `TAttrs` into `TStylingStatic`.\n *\n * @param stylingKey existing `TStylingKey` to update or wrap.\n * @param attrs `TAttributes` to process.\n * @param isClassBased `true` if `class` (`false` if `style`)\n */\nfunction collectStylingFromTAttrs(\n    stylingKey: TStylingKey | undefined, attrs: TAttributes | null,\n    isClassBased: boolean): TStylingKey {\n  const desiredMarker = isClassBased ? AttributeMarker.Classes : AttributeMarker.Styles;\n  let currentMarker = AttributeMarker.ImplicitAttributes;\n  if (attrs !== null) {\n    for (let i = 0; i < attrs.length; i++) {\n      const item = attrs[i] as number | string;\n      if (typeof item === 'number') {\n        currentMarker = item;\n      } else {\n        if (currentMarker === desiredMarker) {\n          if (!Array.isArray(stylingKey)) {\n            stylingKey = stylingKey === undefined ? [] : ['', stylingKey] as any;\n          }\n          keyValueArraySet(\n              stylingKey as KeyValueArray<any>, item, isClassBased ? true : attrs[++i]);\n        }\n      }\n    }\n  }\n  return stylingKey === undefined ? null : stylingKey;\n}\n\n/**\n * Retrieve the current `DirectiveDef` which is active when `hostBindings` style instruction is\n * being executed (or `null` if we are in `template`.)\n *\n * @param tData Current `TData` where the `DirectiveDef` will be looked up at.\n */\nexport function getHostDirectiveDef(tData: TData): DirectiveDef<any>|null {\n  const currentDirectiveIndex = getCurrentDirectiveIndex();\n  return currentDirectiveIndex === -1 ? null : tData[currentDirectiveIndex] as DirectiveDef<any>;\n}\n\n/**\n * Convert user input to `KeyValueArray`.\n *\n * This function takes user input which could be `string`, Object literal, or iterable and converts\n * it into a consistent representation. The output of this is `KeyValueArray` (which is an array\n * where\n * even indexes contain keys and odd indexes contain values for those keys).\n *\n * The advantage of converting to `KeyValueArray` is that we can perform diff in an input\n * independent\n * way.\n * (ie we can compare `foo bar` to `['bar', 'baz'] and determine a set of changes which need to be\n * applied)\n *\n * The fact that `KeyValueArray` is sorted is very important because it allows us to compute the\n * difference in linear fashion without the need to allocate any additional data.\n *\n * For example if we kept this as a `Map` we would have to iterate over previous `Map` to determine\n * which values need to be deleted, over the new `Map` to determine additions, and we would have to\n * keep additional `Map` to keep track of duplicates or items which have not yet been visited.\n *\n * @param keyValueArraySet (See `keyValueArraySet` in \"util/array_utils\") Gets passed in as a\n * function so that\n *        `style` can pass in version which does sanitization. This is done for tree shaking\n *        purposes.\n * @param stringParser The parser is passed in so that it will be tree shakable. See\n *        `styleStringParser` and `classStringParser`\n * @param value The value to parse/convert to `KeyValueArray`\n */\nexport function toStylingKeyValueArray(\n    keyValueArraySet: (keyValueArray: KeyValueArray<any>, key: string, value: any) => void,\n    stringParser: (styleKeyValueArray: KeyValueArray<any>, text: string) => void, value: string|\n    string[]|{[key: string]: any}|Map<any, any>|Set<any>|null|undefined): KeyValueArray<any> {\n  if (value == null /*|| value === undefined */ || value === '') return EMPTY_ARRAY as any;\n  const styleKeyValueArray: KeyValueArray<any> = [] as any;\n  if (Array.isArray(value)) {\n    for (let i = 0; i < value.length; i++) {\n      keyValueArraySet(styleKeyValueArray, value[i], true);\n    }\n  } else if (typeof value === 'object') {\n    if (value instanceof Map) {\n      value.forEach((v, k) => keyValueArraySet(styleKeyValueArray, k, v));\n    } else if (value instanceof Set) {\n      value.forEach((k) => keyValueArraySet(styleKeyValueArray, k, true));\n    } else {\n      for (const key in value) {\n        if (value.hasOwnProperty(key)) {\n          keyValueArraySet(styleKeyValueArray, key, value[key]);\n        }\n      }\n    }\n  } else if (typeof value === 'string') {\n    stringParser(styleKeyValueArray, value);\n  } else {\n    ngDevMode && throwError('Unsupported styling type ' + typeof value + ': ' + value);\n  }\n  return styleKeyValueArray;\n}\n\n/**\n * Set a `value` for a `key` taking style sanitization into account.\n *\n * See: `keyValueArraySet` for details\n *\n * @param keyValueArray KeyValueArray to add to.\n * @param key Style key to add. (This key will be checked if it needs sanitization)\n * @param value The value to set (If key needs sanitization it will be sanitized)\n */\nfunction styleKeyValueArraySet(keyValueArray: KeyValueArray<any>, key: string, value: any) {\n  if (stylePropNeedsSanitization(key)) {\n    value = ɵɵsanitizeStyle(value);\n  }\n  keyValueArraySet(keyValueArray, key, value);\n}\n\n/**\n * Update map based styling.\n *\n * Map based styling could be anything which contains more than one binding. For example `string`,\n * `Map`, `Set` or object literal. Dealing with all of these types would complicate the logic so\n * instead this function expects that the complex input is first converted into normalized\n * `KeyValueArray`. The advantage of normalization is that we get the values sorted, which makes it\n * very\n * cheap to compute deltas between the previous and current value.\n *\n * @param tView Associated `TView.data` contains the linked list of binding priorities.\n * @param tNode `TNode` where the binding is located.\n * @param lView `LView` contains the values associated with other styling binding at this `TNode`.\n * @param renderer Renderer to use if any updates.\n * @param oldKeyValueArray Previous value represented as `KeyValueArray`\n * @param newKeyValueArray Current value represented as `KeyValueArray`\n * @param isClassBased `true` if `class` (`false` if `style`)\n * @param bindingIndex Binding index of the binding.\n */\nfunction updateStylingMap(\n    tView: TView, tNode: TNode, lView: LView, renderer: Renderer3,\n    oldKeyValueArray: KeyValueArray<any>, newKeyValueArray: KeyValueArray<any>,\n    isClassBased: boolean, bindingIndex: number) {\n  if (oldKeyValueArray as KeyValueArray<any>| NO_CHANGE === NO_CHANGE) {\n    // On first execution the oldKeyValueArray is NO_CHANGE => treat it as empty KeyValueArray.\n    oldKeyValueArray = EMPTY_ARRAY as any;\n  }\n  let oldIndex = 0;\n  let newIndex = 0;\n  let oldKey: string|null = 0 < oldKeyValueArray.length ? oldKeyValueArray[0] : null;\n  let newKey: string|null = 0 < newKeyValueArray.length ? newKeyValueArray[0] : null;\n  while (oldKey !== null || newKey !== null) {\n    ngDevMode && assertLessThan(oldIndex, 999, 'Are we stuck in infinite loop?');\n    ngDevMode && assertLessThan(newIndex, 999, 'Are we stuck in infinite loop?');\n    const oldValue =\n        oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex + 1] : undefined;\n    const newValue =\n        newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex + 1] : undefined;\n    let setKey: string|null = null;\n    let setValue: any = undefined;\n    if (oldKey === newKey) {\n      // UPDATE: Keys are equal => new value is overwriting old value.\n      oldIndex += 2;\n      newIndex += 2;\n      if (oldValue !== newValue) {\n        setKey = newKey;\n        setValue = newValue;\n      }\n    } else if (newKey === null || oldKey !== null && oldKey < newKey !) {\n      // DELETE: oldKey key is missing or we did not find the oldKey in the newValue\n      // (because the keyValueArray is sorted and `newKey` is found later alphabetically).\n      // `\"background\" < \"color\"` so we need to delete `\"background\"` because it is not found in the\n      // new array.\n      oldIndex += 2;\n      setKey = oldKey;\n    } else {\n      // CREATE: newKey's is earlier alphabetically than oldKey's (or no oldKey) => we have new key.\n      // `\"color\" > \"background\"` so we need to add `color` because it is in new array but not in\n      // old array.\n      ngDevMode && assertDefined(newKey, 'Expecting to have a valid key');\n      newIndex += 2;\n      setKey = newKey;\n      setValue = newValue;\n    }\n    if (setKey !== null) {\n      updateStyling(tView, tNode, lView, renderer, setKey, setValue, isClassBased, bindingIndex);\n    }\n    oldKey = oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex] : null;\n    newKey = newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex] : null;\n  }\n}\n\n/**\n * Update a simple (property name) styling.\n *\n * This function takes `prop` and updates the DOM to that value. The function takes the binding\n * value as well as binding priority into consideration to determine which value should be written\n * to DOM. (For example it may be determined that there is a higher priority overwrite which blocks\n * the DOM write, or if the value goes to `undefined` a lower priority overwrite may be consulted.)\n *\n * @param tView Associated `TView.data` contains the linked list of binding priorities.\n * @param tNode `TNode` where the binding is located.\n * @param lView `LView` contains the values associated with other styling binding at this `TNode`.\n * @param renderer Renderer to use if any updates.\n * @param prop Either style property name or a class name.\n * @param value Either style value for `prop` or `true`/`false` if `prop` is class.\n * @param isClassBased `true` if `class` (`false` if `style`)\n * @param bindingIndex Binding index of the binding.\n */\nfunction updateStyling(\n    tView: TView, tNode: TNode, lView: LView, renderer: Renderer3, prop: string,\n    value: string | undefined | null | boolean, isClassBased: boolean, bindingIndex: number) {\n  if (tNode.type !== TNodeType.Element) {\n    // It is possible to have styling on non-elements (such as ng-container).\n    // This is rare, but it does happen. In such a case, just ignore the binding.\n    return;\n  }\n  const tData = tView.data;\n  const tRange = tData[bindingIndex + 1] as TStylingRange;\n  const higherPriorityValue = getTStylingRangeNextDuplicate(tRange) ?\n      findStylingValue(tData, tNode, lView, prop, getTStylingRangeNext(tRange), isClassBased) :\n      undefined;\n  if (!isStylingValuePresent(higherPriorityValue)) {\n    // We don't have a next duplicate, or we did not find a duplicate value.\n    if (!isStylingValuePresent(value)) {\n      // We should delete current value or restore to lower priority value.\n      if (getTStylingRangePrevDuplicate(tRange)) {\n        // We have a possible prev duplicate, let's retrieve it.\n        value = findStylingValue(tData, null, lView, prop, bindingIndex, isClassBased);\n      }\n    }\n    const rNode = getNativeByIndex(getSelectedIndex(), lView) as RElement;\n    applyStyling(renderer, isClassBased, rNode, prop, value);\n  }\n}\n\n/**\n * Search for styling value with higher priority which is overwriting current value, or a\n * value of lower priority to which we should fall back if the value is `undefined`.\n *\n * When value is being applied at a location, related values need to be consulted.\n * - If there is a higher priority binding, we should be using that one instead.\n *   For example `<div  [style]=\"{color:exp1}\" [style.color]=\"exp2\">` change to `exp1`\n *   requires that we check `exp2` to see if it is set to value other than `undefined`.\n * - If there is a lower priority binding and we are changing to `undefined`\n *   For example `<div  [style]=\"{color:exp1}\" [style.color]=\"exp2\">` change to `exp2` to\n *   `undefined` requires that we check `exp1` (and static values) and use that as new value.\n *\n * NOTE: The styling stores two values.\n * 1. The raw value which came from the application is stored at `index + 0` location. (This value\n *    is used for dirty checking).\n * 2. The normalized value (converted to `KeyValueArray` if map and sanitized) is stored at `index +\n * 1`.\n *    The advantage of storing the sanitized value is that once the value is written we don't need\n *    to worry about sanitizing it later or keeping track of the sanitizer.\n *\n * @param tData `TData` used for traversing the priority.\n * @param tNode `TNode` to use for resolving static styling. Also controls search direction.\n *   - `TNode` search next and quit as soon as `isStylingValuePresent(value)` is true.\n *      If no value found consult `tNode.residualStyle`/`tNode.residualClass` for default value.\n *   - `null` search prev and go all the way to end. Return last value where\n *     `isStylingValuePresent(value)` is true.\n * @param lView `LView` used for retrieving the actual values.\n * @param prop Property which we are interested in.\n * @param index Starting index in the linked list of styling bindings where the search should start.\n * @param isClassBased `true` if `class` (`false` if `style`)\n */\nfunction findStylingValue(\n    tData: TData, tNode: TNode | null, lView: LView, prop: string, index: number,\n    isClassBased: boolean): any {\n  // `TNode` to use for resolving static styling. Also controls search direction.\n  //   - `TNode` search next and quit as soon as `isStylingValuePresent(value)` is true.\n  //      If no value found consult `tNode.residualStyle`/`tNode.residualClass` for default value.\n  //   - `null` search prev and go all the way to end. Return last value where\n  //     `isStylingValuePresent(value)` is true.\n  const isPrevDirection = tNode === null;\n  let value: any = undefined;\n  while (index > 0) {\n    const rawKey = tData[index] as TStylingKey;\n    const containsStatics = Array.isArray(rawKey);\n    // Unwrap the key if we contain static values.\n    const key = containsStatics ? (rawKey as string[])[1] : rawKey;\n    const isStylingMap = key === null;\n    let valueAtLViewIndex = lView[index + 1];\n    if (valueAtLViewIndex === NO_CHANGE) {\n      // In firstUpdatePass the styling instructions create a linked list of styling.\n      // On subsequent passes it is possible for a styling instruction to try to read a binding\n      // which\n      // has not yet executed. In that case we will find `NO_CHANGE` and we should assume that\n      // we have `undefined` (or empty array in case of styling-map instruction) instead. This\n      // allows the resolution to apply the value (which may later be overwritten when the\n      // binding actually executes.)\n      valueAtLViewIndex = isStylingMap ? EMPTY_ARRAY : undefined;\n    }\n    let currentValue = isStylingMap ? keyValueArrayGet(valueAtLViewIndex, prop) :\n                                      key === prop ? valueAtLViewIndex : undefined;\n    if (containsStatics && !isStylingValuePresent(currentValue)) {\n      currentValue = keyValueArrayGet(rawKey as KeyValueArray<any>, prop);\n    }\n    if (isStylingValuePresent(currentValue)) {\n      value = currentValue;\n      if (isPrevDirection) {\n        return value;\n      }\n    }\n    const tRange = tData[index + 1] as TStylingRange;\n    index = isPrevDirection ? getTStylingRangePrev(tRange) : getTStylingRangeNext(tRange);\n  }\n  if (tNode !== null) {\n    // in case where we are going in next direction AND we did not find anything, we need to\n    // consult residual styling\n    let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;\n    if (residual != null /** OR residual !=== undefined */) {\n      value = keyValueArrayGet(residual !, prop);\n    }\n  }\n  return value;\n}\n\n/**\n * Determines if the binding value should be used (or if the value is 'undefined' and hence priority\n * resolution should be used.)\n *\n * @param value Binding style value.\n */\nfunction isStylingValuePresent(value: any): boolean {\n  // Currently only `undefined` value is considered non-binding. That is `undefined` says I don't\n  // have an opinion as to what this binding should be and you should consult other bindings by\n  // priority to determine the valid value.\n  // This is extracted into a single function so that we have a single place to control this.\n  return value !== undefined;\n}\n\n/**\n * Sanitizes or adds suffix to the value.\n *\n * If value is `null`/`undefined` no suffix is added\n * @param value\n * @param suffixOrSanitizer\n */\nfunction normalizeAndApplySuffixOrSanitizer(\n    value: any, suffixOrSanitizer: SanitizerFn | string | undefined | null): string|null|undefined|\n    boolean {\n  if (value == null /** || value === undefined */) {\n    // do nothing\n  } else if (typeof suffixOrSanitizer === 'function') {\n    // sanitize the value.\n    value = suffixOrSanitizer(value);\n  } else if (typeof suffixOrSanitizer === 'string') {\n    value = value + suffixOrSanitizer;\n  } else if (typeof value === 'object') {\n    value = stringify(unwrapSafeValue(value));\n  }\n  return value;\n}\n\n\n/**\n * Tests if the `TNode` has input shadow.\n *\n * An input shadow is when a directive steals (shadows) the input by using `@Input('style')` or\n * `@Input('class')` as input.\n *\n * @param tNode `TNode` which we would like to see if it has shadow.\n * @param isClassBased `true` if `class` (`false` if `style`)\n */\nexport function hasStylingInputShadow(tNode: TNode, isClassBased: boolean) {\n  return (tNode.flags & (isClassBased ? TNodeFlags.hasClassInput : TNodeFlags.hasStyleInput)) !== 0;\n}\n"]}