@angular/core
Version:
Angular - the core framework
408 lines • 44.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { setStylingMapsSyncFn } from './bindings';
import { getBindingValue, getValuesCount, isStylingValueDefined } from './util';
/**
* Used to apply styling values presently within any map-based bindings on an element.
*
* Angular supports map-based styling bindings which can be applied via the
* `[style]` and `[class]` bindings which can be placed on any HTML element.
* These bindings can work independently, together or alongside prop-based
* styling bindings (e.g. `<div [style]="x" [style.width]="w">`).
*
* If a map-based styling binding is detected by the compiler, the following
* AOT code is produced:
*
* ```typescript
* styleMap(ctx.styles); // styles = {key:value}
* classMap(ctx.classes); // classes = {key:value}|string
* ```
*
* If and when either of the instructions above are evaluated, then the code
* present in this file is included into the bundle. The mechanism used, to
* activate support for map-based bindings at runtime is possible via the
* `activeStylingMapFeature` function (which is also present in this file).
*
* # The Algorithm
* Whenever a map-based binding updates (which is when the identity of the
* map-value changes) then the map is iterated over and a `LStylingMap` array
* is produced. The `LStylingMap` instance is stored in the binding location
* where the `BINDING_INDEX` is situated when the `styleMap()` or `classMap()`
* instruction were called. Once the binding changes, then the internal `bitMask`
* value is marked as dirty.
*
* Styling values are applied once CD exits the element (which happens when
* the `select(n)` instruction is called or the template function exits). When
* this occurs, all prop-based bindings are applied. If a map-based binding is
* present then a special flushing function (called a sync function) is made
* available and it will be called each time a styling property is flushed.
*
* The flushing algorithm is designed to apply styling for a property (which is
* a CSS property or a className value) one by one. If map-based bindings
* are present, then the flushing algorithm will keep calling the maps styling
* sync function each time a property is visited. This way, the flushing
* behavior of map-based bindings will always be at the same property level
* as the current prop-based property being iterated over (because everything
* is alphabetically sorted).
*
* Let's imagine we have the following HTML template code:
*
* ```html
* <div [style]="{width:'100px', height:'200px', 'z-index':'10'}"
* [style.width.px]="200">...</div>
* ```
*
* When CD occurs, both the `[style]` and `[style.width]` bindings
* are evaluated. Then when the styles are flushed on screen, the
* following operations happen:
*
* 1. `[style.width]` is attempted to be written to the element.
*
* 2. Once that happens, the algorithm instructs the map-based
* entries (`[style]` in this case) to "catch up" and apply
* all values up to the `width` value. When this happens the
* `height` value is applied to the element (since it is
* alphabetically situated before the `width` property).
*
* 3. Since there are no more prop-based entries anymore, the
* loop exits and then, just before the flushing ends, it
* instructs all map-based bindings to "finish up" applying
* their values.
*
* 4. The only remaining value within the map-based entries is
* the `z-index` value (`width` got skipped because it was
* successfully applied via the prop-based `[style.width]`
* binding). Since all map-based entries are told to "finish up",
* the `z-index` value is iterated over and it is then applied
* to the element.
*
* The most important thing to take note of here is that prop-based
* bindings are evaluated in order alongside map-based bindings.
* This allows all styling across an element to be applied in O(n)
* time (a similar algorithm is that of the array merge algorithm
* in merge sort).
* @type {?}
*/
export const syncStylingMap = (/**
* @param {?} context
* @param {?} renderer
* @param {?} element
* @param {?} data
* @param {?} applyStylingFn
* @param {?} sanitizer
* @param {?} mode
* @param {?=} targetProp
* @param {?=} defaultValue
* @return {?}
*/
(context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp, defaultValue) => {
/** @type {?} */
let targetPropValueWasApplied = false;
// once the map-based styling code is activate it is never deactivated. For this reason a
// check to see if the current styling context has any map based bindings is required.
/** @type {?} */
const totalMaps = getValuesCount(context, 2 /* MapBindingsPosition */);
if (totalMaps) {
/** @type {?} */
let runTheSyncAlgorithm = true;
/** @type {?} */
const loopUntilEnd = !targetProp;
// If the code is told to finish up (run until the end), but the mode
// hasn't been flagged to apply values (it only traverses values) then
// there is no point in iterating over the array because nothing will
// be applied to the element.
if (loopUntilEnd && (mode & ~1 /* ApplyAllValues */)) {
runTheSyncAlgorithm = false;
targetPropValueWasApplied = true;
}
if (runTheSyncAlgorithm) {
targetPropValueWasApplied = innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp || null, 0, defaultValue || null);
}
if (loopUntilEnd) {
resetSyncCursors();
}
}
return targetPropValueWasApplied;
});
/**
* Recursive function designed to apply map-based styling to an element one map at a time.
*
* This function is designed to be called from the `syncStylingMap` function and will
* apply map-based styling data one map at a time to the provided `element`.
*
* This function is recursive and it will call itself if a follow-up map value is to be
* processed. To learn more about how the algorithm works, see `syncStylingMap`.
* @param {?} context
* @param {?} renderer
* @param {?} element
* @param {?} data
* @param {?} applyStylingFn
* @param {?} sanitizer
* @param {?} mode
* @param {?} targetProp
* @param {?} currentMapIndex
* @param {?} defaultValue
* @return {?}
*/
function innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp, currentMapIndex, defaultValue) {
/** @type {?} */
let targetPropValueWasApplied = false;
/** @type {?} */
const totalMaps = getValuesCount(context, 2 /* MapBindingsPosition */);
if (currentMapIndex < totalMaps) {
/** @type {?} */
const bindingIndex = (/** @type {?} */ (getBindingValue(context, 2 /* MapBindingsPosition */, currentMapIndex)));
/** @type {?} */
const lStylingMap = (/** @type {?} */ (data[bindingIndex]));
/** @type {?} */
let cursor = getCurrentSyncCursor(currentMapIndex);
while (cursor < lStylingMap.length) {
/** @type {?} */
const prop = getMapProp(lStylingMap, cursor);
/** @type {?} */
const iteratedTooFar = targetProp && prop > targetProp;
/** @type {?} */
const isTargetPropMatched = !iteratedTooFar && prop === targetProp;
/** @type {?} */
const value = getMapValue(lStylingMap, cursor);
/** @type {?} */
const valueIsDefined = isStylingValueDefined(value);
// the recursive code is designed to keep applying until
// it reaches or goes past the target prop. If and when
// this happens then it will stop processing values, but
// all other map values must also catch up to the same
// point. This is why a recursive call is still issued
// even if the code has iterated too far.
/** @type {?} */
const innerMode = iteratedTooFar ? mode : resolveInnerMapMode(mode, valueIsDefined, isTargetPropMatched);
/** @type {?} */
const innerProp = iteratedTooFar ? targetProp : prop;
/** @type {?} */
let valueApplied = innerSyncStylingMap(context, renderer, element, data, applyStylingFn, sanitizer, innerMode, innerProp, currentMapIndex + 1, defaultValue);
if (iteratedTooFar) {
break;
}
if (!valueApplied && isValueAllowedToBeApplied(mode, isTargetPropMatched)) {
/** @type {?} */
const useDefault = isTargetPropMatched && !valueIsDefined;
/** @type {?} */
const valueToApply = useDefault ? defaultValue : value;
/** @type {?} */
const bindingIndexToApply = useDefault ? bindingIndex : null;
/** @type {?} */
const finalValue = sanitizer ?
sanitizer(prop, valueToApply, 3 /* ValidateAndSanitize */) :
valueToApply;
applyStylingFn(renderer, element, prop, finalValue, bindingIndexToApply);
valueApplied = true;
}
targetPropValueWasApplied = valueApplied && isTargetPropMatched;
cursor += 2 /* TupleSize */;
}
setCurrentSyncCursor(currentMapIndex, cursor);
}
return targetPropValueWasApplied;
}
/**
* Enables support for map-based styling bindings (e.g. `[style]` and `[class]` bindings).
* @return {?}
*/
export function activeStylingMapFeature() {
setStylingMapsSyncFn(syncStylingMap);
}
/**
* Used to determine the mode for the inner recursive call.
*
* If an inner map is iterated on then this is done so for one
* of two reasons:
*
* - The target property was detected and the inner map
* must now "catch up" (pointer-wise) up to where the current
* map's cursor is situated.
*
* - The target property was not detected in the current map
* and must be found in an inner map. This can only be allowed
* if the current map iteration is not set to skip the target
* property.
* @param {?} currentMode
* @param {?} valueIsDefined
* @param {?} isExactMatch
* @return {?}
*/
function resolveInnerMapMode(currentMode, valueIsDefined, isExactMatch) {
/** @type {?} */
let innerMode = currentMode;
if (!valueIsDefined && isExactMatch && !(currentMode & 4 /* SkipTargetProp */)) {
// case 1: set the mode to apply the targeted prop value if it
// ends up being encountered in another map value
innerMode |= 2 /* ApplyTargetProp */;
innerMode &= ~4 /* SkipTargetProp */;
}
else {
// case 2: set the mode to skip the targeted prop value if it
// ends up being encountered in another map value
innerMode |= 4 /* SkipTargetProp */;
innerMode &= ~2 /* ApplyTargetProp */;
}
return innerMode;
}
/**
* Decides whether or not a prop/value entry will be applied to an element.
*
* To determine whether or not a value is to be applied,
* the following procedure is evaluated:
*
* First check to see the current `mode` status:
* 1. If the mode value permits all props to be applied then allow.
* - But do not allow if the current prop is set to be skipped.
* 2. Otherwise if the current prop is permitted then allow.
* @param {?} mode
* @param {?} isTargetPropMatched
* @return {?}
*/
function isValueAllowedToBeApplied(mode, isTargetPropMatched) {
/** @type {?} */
let doApplyValue = (mode & 1 /* ApplyAllValues */) > 0;
if (!doApplyValue) {
if (mode & 2 /* ApplyTargetProp */) {
doApplyValue = isTargetPropMatched;
}
}
else if ((mode & 4 /* SkipTargetProp */) && isTargetPropMatched) {
doApplyValue = false;
}
return doApplyValue;
}
/**
* Used to keep track of concurrent cursor values for multiple map-based styling bindings present on
* an element.
* @type {?}
*/
const MAP_CURSORS = [];
/**
* Used to reset the state of each cursor value being used to iterate over map-based styling
* bindings.
* @return {?}
*/
function resetSyncCursors() {
for (let i = 0; i < MAP_CURSORS.length; i++) {
MAP_CURSORS[i] = 1 /* ValuesStartPosition */;
}
}
/**
* Returns an active cursor value at a given mapIndex location.
* @param {?} mapIndex
* @return {?}
*/
function getCurrentSyncCursor(mapIndex) {
if (mapIndex >= MAP_CURSORS.length) {
MAP_CURSORS.push(1 /* ValuesStartPosition */);
}
return MAP_CURSORS[mapIndex];
}
/**
* Sets a cursor value at a given mapIndex location.
* @param {?} mapIndex
* @param {?} indexValue
* @return {?}
*/
function setCurrentSyncCursor(mapIndex, indexValue) {
MAP_CURSORS[mapIndex] = indexValue;
}
/**
* Used to convert a {key:value} map into a `LStylingMap` array.
*
* This function will either generate a new `LStylingMap` instance
* or it will patch the provided `newValues` map value into an
* existing `LStylingMap` value (this only happens if `bindingValue`
* is an instance of `LStylingMap`).
*
* If a new key/value map is provided with an old `LStylingMap`
* value then all properties will be overwritten with their new
* values or with `null`. This means that the array will never
* shrink in size (but it will also not be created and thrown
* away whenever the {key:value} map entries change).
* @param {?} bindingValue
* @param {?} newValues
* @return {?}
*/
export function normalizeIntoStylingMap(bindingValue, newValues) {
/** @type {?} */
const lStylingMap = Array.isArray(bindingValue) ? bindingValue : [null];
lStylingMap[0 /* RawValuePosition */] = newValues || null;
// because the new values may not include all the properties
// that the old ones had, all values are set to `null` before
// the new values are applied. This way, when flushed, the
// styling algorithm knows exactly what style/class values
// to remove from the element (since they are `null`).
for (let j = 1 /* ValuesStartPosition */; j < lStylingMap.length; j += 2 /* TupleSize */) {
setMapValue(lStylingMap, j, null);
}
/** @type {?} */
let props = null;
/** @type {?} */
let map;
/** @type {?} */
let allValuesTrue = false;
if (typeof newValues === 'string') { // [class] bindings allow string values
if (newValues.length) {
props = newValues.split(/\s+/);
allValuesTrue = true;
}
}
else {
props = newValues ? Object.keys(newValues) : null;
map = newValues;
}
if (props) {
outer: for (let i = 0; i < props.length; i++) {
/** @type {?} */
const prop = (/** @type {?} */ (props[i]));
/** @type {?} */
const value = allValuesTrue ? true : (/** @type {?} */ (map))[prop];
for (let j = 1 /* ValuesStartPosition */; j < lStylingMap.length; j += 2 /* TupleSize */) {
/** @type {?} */
const propAtIndex = getMapProp(lStylingMap, j);
if (prop <= propAtIndex) {
if (propAtIndex === prop) {
setMapValue(lStylingMap, j, value);
}
else {
lStylingMap.splice(j, 0, prop, value);
}
continue outer;
}
}
lStylingMap.push(prop, value);
}
}
return lStylingMap;
}
/**
* @param {?} map
* @param {?} index
* @return {?}
*/
export function getMapProp(map, index) {
return (/** @type {?} */ (map[index + 0 /* PropOffset */]));
}
/**
* @param {?} map
* @param {?} index
* @param {?} value
* @return {?}
*/
export function setMapValue(map, index, value) {
map[index + 1 /* ValueOffset */] = value;
}
/**
* @param {?} map
* @param {?} index
* @return {?}
*/
export function getMapValue(map, index) {
return (/** @type {?} */ (map[index + 1 /* ValueOffset */]));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map_based_bindings.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/styling_next/map_based_bindings.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\nimport {StyleSanitizeFn, StyleSanitizeMode} from '../../sanitization/style_sanitizer';\nimport {ProceduralRenderer3, RElement, Renderer3} from '../interfaces/renderer';\n\nimport {setStylingMapsSyncFn} from './bindings';\nimport {ApplyStylingFn, LStylingData, LStylingMap, LStylingMapIndex, StylingMapsSyncMode, SyncStylingMapsFn, TStylingContext, TStylingContextIndex} from './interfaces';\nimport {getBindingValue, getValuesCount, isStylingValueDefined} from './util';\n\n\n/**\n * --------\n *\n * This file contains the algorithm logic for applying map-based bindings\n * such as `[style]` and `[class]`.\n *\n * --------\n */\n\n/**\n * Used to apply styling values presently within any map-based bindings on an element.\n *\n * Angular supports map-based styling bindings which can be applied via the\n * `[style]` and `[class]` bindings which can be placed on any HTML element.\n * These bindings can work independently, together or alongside prop-based\n * styling bindings (e.g. `<div [style]=\"x\" [style.width]=\"w\">`).\n *\n * If a map-based styling binding is detected by the compiler, the following\n * AOT code is produced:\n *\n * ```typescript\n * styleMap(ctx.styles); // styles = {key:value}\n * classMap(ctx.classes); // classes = {key:value}|string\n * ```\n *\n * If and when either of the instructions above are evaluated, then the code\n * present in this file is included into the bundle. The mechanism used, to\n * activate support for map-based bindings at runtime is possible via the\n * `activeStylingMapFeature` function (which is also present in this file).\n *\n * # The Algorithm\n * Whenever a map-based binding updates (which is when the identity of the\n * map-value changes) then the map is iterated over and a `LStylingMap` array\n * is produced. The `LStylingMap` instance is stored in the binding location\n * where the `BINDING_INDEX` is situated when the `styleMap()` or `classMap()`\n * instruction were called. Once the binding changes, then the internal `bitMask`\n * value is marked as dirty.\n *\n * Styling values are applied once CD exits the element (which happens when\n * the `select(n)` instruction is called or the template function exits). When\n * this occurs, all prop-based bindings are applied. If a map-based binding is\n * present then a special flushing function (called a sync function) is made\n * available and it will be called each time a styling property is flushed.\n *\n * The flushing algorithm is designed to apply styling for a property (which is\n * a CSS property or a className value) one by one. If map-based bindings\n * are present, then the flushing algorithm will keep calling the maps styling\n * sync function each time a property is visited. This way, the flushing\n * behavior of map-based bindings will always be at the same property level\n * as the current prop-based property being iterated over (because everything\n * is alphabetically sorted).\n *\n * Let's imagine we have the following HTML template code:\n *\n * ```html\n * <div [style]=\"{width:'100px', height:'200px', 'z-index':'10'}\"\n *      [style.width.px]=\"200\">...</div>\n * ```\n *\n * When CD occurs, both the `[style]` and `[style.width]` bindings\n * are evaluated. Then when the styles are flushed on screen, the\n * following operations happen:\n *\n * 1. `[style.width]` is attempted to be written to the element.\n *\n * 2.  Once that happens, the algorithm instructs the map-based\n *     entries (`[style]` in this case) to \"catch up\" and apply\n *     all values up to the `width` value. When this happens the\n *     `height` value is applied to the element (since it is\n *     alphabetically situated before the `width` property).\n *\n * 3. Since there are no more prop-based entries anymore, the\n *    loop exits and then, just before the flushing ends, it\n *    instructs all map-based bindings to \"finish up\" applying\n *    their values.\n *\n * 4. The only remaining value within the map-based entries is\n *    the `z-index` value (`width` got skipped because it was\n *    successfully applied via the prop-based `[style.width]`\n *    binding). Since all map-based entries are told to \"finish up\",\n *    the `z-index` value is iterated over and it is then applied\n *    to the element.\n *\n * The most important thing to take note of here is that prop-based\n * bindings are evaluated in order alongside map-based bindings.\n * This allows all styling across an element to be applied in O(n)\n * time (a similar algorithm is that of the array merge algorithm\n * in merge sort).\n */\nexport const syncStylingMap: SyncStylingMapsFn =\n    (context: TStylingContext, renderer: Renderer3 | ProceduralRenderer3 | null, element: RElement,\n     data: LStylingData, applyStylingFn: ApplyStylingFn, sanitizer: StyleSanitizeFn | null,\n     mode: StylingMapsSyncMode, targetProp?: string | null,\n     defaultValue?: string | null): boolean => {\n      let targetPropValueWasApplied = false;\n\n      // once the map-based styling code is activate it is never deactivated. For this reason a\n      // check to see if the current styling context has any map based bindings is required.\n      const totalMaps = getValuesCount(context, TStylingContextIndex.MapBindingsPosition);\n      if (totalMaps) {\n        let runTheSyncAlgorithm = true;\n        const loopUntilEnd = !targetProp;\n\n        // If the code is told to finish up (run until the end), but the mode\n        // hasn't been flagged to apply values (it only traverses values) then\n        // there is no point in iterating over the array because nothing will\n        // be applied to the element.\n        if (loopUntilEnd && (mode & ~StylingMapsSyncMode.ApplyAllValues)) {\n          runTheSyncAlgorithm = false;\n          targetPropValueWasApplied = true;\n        }\n\n        if (runTheSyncAlgorithm) {\n          targetPropValueWasApplied = innerSyncStylingMap(\n              context, renderer, element, data, applyStylingFn, sanitizer, mode, targetProp || null,\n              0, defaultValue || null);\n        }\n\n        if (loopUntilEnd) {\n          resetSyncCursors();\n        }\n      }\n\n      return targetPropValueWasApplied;\n    };\n\n/**\n * Recursive function designed to apply map-based styling to an element one map at a time.\n *\n * This function is designed to be called from the `syncStylingMap` function and will\n * apply map-based styling data one map at a time to the provided `element`.\n *\n * This function is recursive and it will call itself if a follow-up map value is to be\n * processed. To learn more about how the algorithm works, see `syncStylingMap`.\n */\nfunction innerSyncStylingMap(\n    context: TStylingContext, renderer: Renderer3 | ProceduralRenderer3 | null, element: RElement,\n    data: LStylingData, applyStylingFn: ApplyStylingFn, sanitizer: StyleSanitizeFn | null,\n    mode: StylingMapsSyncMode, targetProp: string | null, currentMapIndex: number,\n    defaultValue: string | null): boolean {\n  let targetPropValueWasApplied = false;\n\n  const totalMaps = getValuesCount(context, TStylingContextIndex.MapBindingsPosition);\n  if (currentMapIndex < totalMaps) {\n    const bindingIndex = getBindingValue(\n        context, TStylingContextIndex.MapBindingsPosition, currentMapIndex) as number;\n    const lStylingMap = data[bindingIndex] as LStylingMap;\n\n    let cursor = getCurrentSyncCursor(currentMapIndex);\n    while (cursor < lStylingMap.length) {\n      const prop = getMapProp(lStylingMap, cursor);\n      const iteratedTooFar = targetProp && prop > targetProp;\n      const isTargetPropMatched = !iteratedTooFar && prop === targetProp;\n      const value = getMapValue(lStylingMap, cursor);\n      const valueIsDefined = isStylingValueDefined(value);\n\n      // the recursive code is designed to keep applying until\n      // it reaches or goes past the target prop. If and when\n      // this happens then it will stop processing values, but\n      // all other map values must also catch up to the same\n      // point. This is why a recursive call is still issued\n      // even if the code has iterated too far.\n      const innerMode =\n          iteratedTooFar ? mode : resolveInnerMapMode(mode, valueIsDefined, isTargetPropMatched);\n      const innerProp = iteratedTooFar ? targetProp : prop;\n      let valueApplied = innerSyncStylingMap(\n          context, renderer, element, data, applyStylingFn, sanitizer, innerMode, innerProp,\n          currentMapIndex + 1, defaultValue);\n\n      if (iteratedTooFar) {\n        break;\n      }\n\n      if (!valueApplied && isValueAllowedToBeApplied(mode, isTargetPropMatched)) {\n        const useDefault = isTargetPropMatched && !valueIsDefined;\n        const valueToApply = useDefault ? defaultValue : value;\n        const bindingIndexToApply = useDefault ? bindingIndex : null;\n        const finalValue = sanitizer ?\n            sanitizer(prop, valueToApply, StyleSanitizeMode.ValidateAndSanitize) :\n            valueToApply;\n        applyStylingFn(renderer, element, prop, finalValue, bindingIndexToApply);\n        valueApplied = true;\n      }\n\n      targetPropValueWasApplied = valueApplied && isTargetPropMatched;\n      cursor += LStylingMapIndex.TupleSize;\n    }\n    setCurrentSyncCursor(currentMapIndex, cursor);\n  }\n\n  return targetPropValueWasApplied;\n}\n\n\n/**\n * Enables support for map-based styling bindings (e.g. `[style]` and `[class]` bindings).\n */\nexport function activeStylingMapFeature() {\n  setStylingMapsSyncFn(syncStylingMap);\n}\n\n/**\n * Used to determine the mode for the inner recursive call.\n *\n * If an inner map is iterated on then this is done so for one\n * of two reasons:\n *\n * - The target property was detected and the inner map\n *   must now \"catch up\" (pointer-wise) up to where the current\n *   map's cursor is situated.\n *\n * - The target property was not detected in the current map\n *   and must be found in an inner map. This can only be allowed\n *   if the current map iteration is not set to skip the target\n *   property.\n */\nfunction resolveInnerMapMode(\n    currentMode: number, valueIsDefined: boolean, isExactMatch: boolean): number {\n  let innerMode = currentMode;\n  if (!valueIsDefined && isExactMatch && !(currentMode & StylingMapsSyncMode.SkipTargetProp)) {\n    // case 1: set the mode to apply the targeted prop value if it\n    // ends up being encountered in another map value\n    innerMode |= StylingMapsSyncMode.ApplyTargetProp;\n    innerMode &= ~StylingMapsSyncMode.SkipTargetProp;\n  } else {\n    // case 2: set the mode to skip the targeted prop value if it\n    // ends up being encountered in another map value\n    innerMode |= StylingMapsSyncMode.SkipTargetProp;\n    innerMode &= ~StylingMapsSyncMode.ApplyTargetProp;\n  }\n  return innerMode;\n}\n\n/**\n * Decides whether or not a prop/value entry will be applied to an element.\n *\n * To determine whether or not a value is to be applied,\n * the following procedure is evaluated:\n *\n * First check to see the current `mode` status:\n *  1. If the mode value permits all props to be applied then allow.\n *    - But do not allow if the current prop is set to be skipped.\n *  2. Otherwise if the current prop is permitted then allow.\n */\nfunction isValueAllowedToBeApplied(mode: number, isTargetPropMatched: boolean) {\n  let doApplyValue = (mode & StylingMapsSyncMode.ApplyAllValues) > 0;\n  if (!doApplyValue) {\n    if (mode & StylingMapsSyncMode.ApplyTargetProp) {\n      doApplyValue = isTargetPropMatched;\n    }\n  } else if ((mode & StylingMapsSyncMode.SkipTargetProp) && isTargetPropMatched) {\n    doApplyValue = false;\n  }\n  return doApplyValue;\n}\n\n/**\n * Used to keep track of concurrent cursor values for multiple map-based styling bindings present on\n * an element.\n */\nconst MAP_CURSORS: number[] = [];\n\n/**\n * Used to reset the state of each cursor value being used to iterate over map-based styling\n * bindings.\n */\nfunction resetSyncCursors() {\n  for (let i = 0; i < MAP_CURSORS.length; i++) {\n    MAP_CURSORS[i] = LStylingMapIndex.ValuesStartPosition;\n  }\n}\n\n/**\n * Returns an active cursor value at a given mapIndex location.\n */\nfunction getCurrentSyncCursor(mapIndex: number) {\n  if (mapIndex >= MAP_CURSORS.length) {\n    MAP_CURSORS.push(LStylingMapIndex.ValuesStartPosition);\n  }\n  return MAP_CURSORS[mapIndex];\n}\n\n/**\n * Sets a cursor value at a given mapIndex location.\n */\nfunction setCurrentSyncCursor(mapIndex: number, indexValue: number) {\n  MAP_CURSORS[mapIndex] = indexValue;\n}\n\n/**\n * Used to convert a {key:value} map into a `LStylingMap` array.\n *\n * This function will either generate a new `LStylingMap` instance\n * or it will patch the provided `newValues` map value into an\n * existing `LStylingMap` value (this only happens if `bindingValue`\n * is an instance of `LStylingMap`).\n *\n * If a new key/value map is provided with an old `LStylingMap`\n * value then all properties will be overwritten with their new\n * values or with `null`. This means that the array will never\n * shrink in size (but it will also not be created and thrown\n * away whenever the {key:value} map entries change).\n */\nexport function normalizeIntoStylingMap(\n    bindingValue: null | LStylingMap,\n    newValues: {[key: string]: any} | string | null | undefined): LStylingMap {\n  const lStylingMap: LStylingMap = Array.isArray(bindingValue) ? bindingValue : [null];\n  lStylingMap[LStylingMapIndex.RawValuePosition] = newValues || null;\n\n  // because the new values may not include all the properties\n  // that the old ones had, all values are set to `null` before\n  // the new values are applied. This way, when flushed, the\n  // styling algorithm knows exactly what style/class values\n  // to remove from the element (since they are `null`).\n  for (let j = LStylingMapIndex.ValuesStartPosition; j < lStylingMap.length;\n       j += LStylingMapIndex.TupleSize) {\n    setMapValue(lStylingMap, j, null);\n  }\n\n  let props: string[]|null = null;\n  let map: {[key: string]: any}|undefined|null;\n  let allValuesTrue = false;\n  if (typeof newValues === 'string') {  // [class] bindings allow string values\n    if (newValues.length) {\n      props = newValues.split(/\\s+/);\n      allValuesTrue = true;\n    }\n  } else {\n    props = newValues ? Object.keys(newValues) : null;\n    map = newValues;\n  }\n\n  if (props) {\n    outer: for (let i = 0; i < props.length; i++) {\n      const prop = props[i] as string;\n      const value = allValuesTrue ? true : map ![prop];\n      for (let j = LStylingMapIndex.ValuesStartPosition; j < lStylingMap.length;\n           j += LStylingMapIndex.TupleSize) {\n        const propAtIndex = getMapProp(lStylingMap, j);\n        if (prop <= propAtIndex) {\n          if (propAtIndex === prop) {\n            setMapValue(lStylingMap, j, value);\n          } else {\n            lStylingMap.splice(j, 0, prop, value);\n          }\n          continue outer;\n        }\n      }\n      lStylingMap.push(prop, value);\n    }\n  }\n\n  return lStylingMap;\n}\n\nexport function getMapProp(map: LStylingMap, index: number): string {\n  return map[index + LStylingMapIndex.PropOffset] as string;\n}\n\nexport function setMapValue(map: LStylingMap, index: number, value: string | null): void {\n  map[index + LStylingMapIndex.ValueOffset] = value;\n}\n\nexport function getMapValue(map: LStylingMap, index: number): string|null {\n  return map[index + LStylingMapIndex.ValueOffset] as string | null;\n}\n"]}