@angular/core 9.0.0-rc.9 → 9.0.0

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

@@ -4,419 +4,227 @@
  * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
- * A static-level representation of all style or class bindings/values
- * associated with a `TNode`.
- *
- * The `TStylingContext` unites all template styling bindings (i.e.
- * `[class]` and `[style]` bindings) as well as all host-level
- * styling bindings (for components and directives) together into
- * a single manifest
- *
- * The styling context is stored on a `TNode` on and there are
- * two instances of it: one for classes and another for styles.
- *
- * ```typescript
- * tNode.styles = [ ... a context only for styles ... ];
- * tNode.classes = [ ... a context only for classes ... ];
- * ```
- *
- * The styling context is created each time there are one or more
- * styling bindings (style or class bindings) present for an element,
- * but is only created once per `TNode`.
- *
- * `tNode.styles` and `tNode.classes` can be an instance of the following:
- *
- * ```typescript
- * tNode.styles = null; // no static styling or styling bindings active
- * tNode.styles = StylingMapArray; // only static values present (e.g. `<div style="width:200">`)
- * tNode.styles = TStylingContext; // one or more styling bindings present (e.g. `<div
- * [style.width]>`)
- * ```
- *
- * Both `tNode.styles` and `tNode.classes` are instantiated when anything
- * styling-related is active on an element. They are first created from
- * from the any of the element-level instructions (e.g. `element`,
- * `elementStart`, `elementHostAttrs`). When any static style/class
- * values are encountered they are registered on the `tNode.styles`
- * and `tNode.classes` data-structures. By default (when any static
- * values are encountered) the `tNode.styles` or `tNode.classes` values
- * are instances of a `StylingMapArray`. Only when style/class bindings
- * are detected then that styling map is converted into an instance of
- * `TStylingContext`.
- *
- * Due to the fact the the `TStylingContext` is stored on a `TNode`
- * this means that all data within the context is static. Instead of
- * storing actual styling binding values, the lView binding index values
- * are stored within the context. (static nature means it is more compact.)
- *
- * The code below shows a breakdown of two instances of `TStylingContext`
- * (one for `tNode.styles` and another for `tNode.classes`):
- *
- * ```typescript
- * // <div [class.active]="c"  // lView binding index = 20
- * //      [style.width]="x"   // lView binding index = 21
- * //      [style.height]="y"> // lView binding index = 22
- * //  ...
- * // </div>
- * tNode.styles = [
- *   1,         // the total amount of sources present (only `1` b/c there are only template
- * bindings)
- *   [null],    // initial values array (an instance of `StylingMapArray`)
+* @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 { assertNumber, assertNumberInRange } from '../../util/assert';
+/**
+ * Store the static values for the styling binding.
  *
- *   0,         // config entry for the property (see `TStylingContextPropConfigFlags`)
- *   0b010,     // template guard mask for height
- *   0,         // host bindings guard mask for height
- *   'height',  // the property name
- *   22,        // the binding location for the "y" binding in the lView
- *   null,      // the default value for height
+ * The `TStylingStatic` is just `KeyValueArray` where key `""` (stored at location 0) contains the
+ * `TStylingKey` (stored at location 1). In other words this wraps the `TStylingKey` such that the
+ * `""` contains the wrapped value.
  *
- *   0,         // config entry for the property (see `TStylingContextPropConfigFlags`)
- *   0b001,     // template guard mask for width
- *   0,         // host bindings guard mask for width
- *   'width',   // the property name
- *   21,        // the binding location for the "x" binding in the lView
- *   null,      // the default value for width
- * ];
+ * When instructions are resolving styling they may need to look forward or backwards in the linked
+ * list to resolve the value. For this reason we have to make sure that he linked list also contains
+ * the static values. However the list only has space for one item per styling instruction. For this
+ * reason we store the static values here as part of the `TStylingKey`. This means that the
+ * resolution function when looking for a value needs to first look at the binding value, and than
+ * at `TStylingKey` (if it exists).
  *
- * tNode.classes = [
- *   0,         // the context config value (see `TStylingContextConfig`)
- *   1,         // the total amount of sources present (only `1` b/c there are only template
- * bindings)
- *   [null],    // initial values array (an instance of `StylingMapArray`)
+ * Imagine we have:
  *
- *   0,         // config entry for the property (see `TStylingContextPropConfigFlags`)
- *   0b001,     // template guard mask for width
- *   0,         // host bindings guard mask for width
- *   'active',  // the property name
- *   20,        // the binding location for the "c" binding in the lView
- *   null,      // the default value for the `active` class
- * ];
  * ```
+ * <div class="TEMPLATE" my-dir>
  *
- * Entry value present in an entry (called a tuple) within the
- * styling context is as follows:
- *
- * ```typescript
- * context = [
- *   //...
- *   configValue,
- *   templateGuardMask,
- *   hostBindingsGuardMask,
- *   propName,
- *   ...bindingIndices...,
- *   defaultValue
- *   //...
- * ];
+ * \@Directive({
+ *   host: {
+ *     class: 'DIR',
+ *     '[class.dynamic]': 'exp' // ɵɵclassProp('dynamic', ctx.exp);
+ *   }
+ * })
  * ```
  *
- * Below is a breakdown of each value:
- *
- * - **configValue**:
- *   Property-specific configuration values. The only config setting
- *   that is implemented right now is whether or not to sanitize the
- *   value.
- *
- * - **templateGuardMask**:
- *   A numeric value where each bit represents a binding index
- *   location. Each binding index location is assigned based on
- *   a local counter value that increments each time an instruction
- *   is called:
+ * In the above case the linked list will contain one item:
  *
  * ```
- * <div [style.width]="x"   // binding index = 21 (counter index = 0)
- *      [style.height]="y"> // binding index = 22 (counter index = 1)
+ *   // assume binding location: 10 for `ɵɵclassProp('dynamic', ctx.exp);`
+ *   tData[10] = <TStylingStatic>[
+ *     '': 'dynamic', // This is the wrapped value of `TStylingKey`
+ *     'DIR': true,   // This is the default static value of directive binding.
+ *   ];
+ *   tData[10 + 1] = 0; // We don't have prev/next.
+ *
+ *   lView[10] = undefined;     // assume `ctx.exp` is `undefined`
+ *   lView[10 + 1] = undefined; // Just normalized `lView[10]`
  * ```
  *
- *   In the example code above, if the `width` value where to change
- *   then the first bit in the local bit mask value would be flipped
- *   (and the second bit for when `height`).
- *
- *   If and when there are more than 32 binding sources in the context
- *   (more than 32 `[style/class]` bindings) then the bit masking will
- *   overflow and we are left with a situation where a `-1` value will
- *   represent the bit mask. Due to the way that JavaScript handles
- *   negative values, when the bit mask is `-1` then all bits within
- *   that value will be automatically flipped (this is a quick and
- *   efficient way to flip all bits on the mask when a special kind
- *   of caching scenario occurs or when there are more than 32 bindings).
- *
- * - **hostBindingsGuardMask**:
- *   Another instance of a guard mask that is specific to host bindings.
- *   This behaves exactly the same way as does the `templateGuardMask`,
- *   but will not contain any binding information processed in the template.
- *   The reason why there are two instances of guard masks (one for the
- *   template and another for host bindings) is because the template bindings
- *   are processed before host bindings and the state information is not
- *   carried over into the host bindings code. As soon as host bindings are
- *   processed for an element the counter and state-based bit mask values are
- *   set to `0`.
+ * So when the function is resolving styling value, it first needs to look into the linked list
+ * (there is none) and than into the static `TStylingStatic` too see if there is a default value for
+ * `dynamic` (there is not). Therefore it is safe to remove it.
  *
+ * If setting `true` case:
  * ```
- * <div [style.width]="x"   // binding index = 21 (counter index = 0)
- *      [style.height]="y"  // binding index = 22 (counter index = 1)
- *      dir-that-sets-width  // binding index = 30 (counter index = 0)
- *      dir-that-sets-width> // binding index = 31 (counter index = 1)
+ *   lView[10] = true;     // assume `ctx.exp` is `true`
+ *   lView[10 + 1] = true; // Just normalized `lView[10]`
  * ```
- *
- * - **propName**:
- *   The CSS property name or class name (e.g `width` or `active`).
- *
- * - **bindingIndices...**:
- *   A series of numeric binding values that reflect where in the
- *   lView to find the style/class values associated with the property.
- *   Each value is in order in terms of priority (templates are first,
- *   then directives and then components). When the context is flushed
- *   and the style/class values are applied to the element (this happens
- *   inside of the `stylingApply` instruction) then the flushing code
- *   will keep checking each binding index against the associated lView
- *   to find the first style/class value that is non-null.
- *
- * - **defaultValue**:
- *   This is the default that will always be applied to the element if
- *   and when all other binding sources return a result that is null.
- *   Usually this value is `null` but it can also be a static value that
- *   is intercepted when the tNode is first constructured (e.g.
- *   `<div style="width:200px">` has a default value of `200px` for
- *   the `width` property).
- *
- * Each time a new binding is encountered it is registered into the
- * context. The context then is continually updated until the first
- * styling apply call has been called (which is automatically scheduled
- * to be called once an element exits during change detection). Note that
- * each entry in the context is stored in alphabetical order.
- *
- * Once styling has been flushed for the first time for an element the
- * context will set as locked (this prevents bindings from being added
- * to the context later on).
- *
- * # How Styles/Classes are Rendered
- * Each time a styling instruction (e.g. `[class.name]`, `[style.prop]`,
- * etc...) is executed, the associated `lView` for the view is updated
- * at the current binding location. Also, when this happens, a local
- * counter value is incremented. If the binding value has changed then
- * a local `bitMask` variable is updated with the specific bit based
- * on the counter value.
- *
- * Below is a lightweight example of what happens when a single style
- * property is updated (i.e. `<div [style.prop]="val">`):
- *
- * ```typescript
- * function updateStyleProp(prop: string, value: string) {
- *   const lView = getLView();
- *   const bindingIndex = BINDING_INDEX++;
- *
- *   // update the local counter value
- *   const indexForStyle = stylingState.stylesCount++;
- *   if (lView[bindingIndex] !== value) {
- *     lView[bindingIndex] = value;
- *
- *     // tell the local state that we have updated a style value
- *     // by updating the bit mask
- *     stylingState.bitMaskForStyles |= 1 << indexForStyle;
- *   }
- * }
+ * So when the function is resolving styling value, it first needs to look into the linked list
+ * (there is none) and than into `TNode.residualClass` (TNode.residualStyle) which contains
  * ```
- *
- * Once all the bindings have updated a `bitMask` value will be populated.
- * This `bitMask` value is used in the apply algorithm (which is called
- * context resolution).
- *
- * ## The Apply Algorithm (Context Resolution)
- * As explained above, each time a binding updates its value, the resulting
- * value is stored in the `lView` array. These styling values have yet to
- * be flushed to the element.
- *
- * Once all the styling instructions have been evaluated, then the styling
- * context(s) are flushed to the element. When this happens, the context will
- * be iterated over (property by property) and each binding source will be
- * examined and the first non-null value will be applied to the element.
- *
- * Let's say that we the following template code:
- *
- * ```html
- * <div [style.width]="w1" dir-that-set-width="w2"></div>
+ *   tNode.residualClass = [
+ *     'TEMPLATE': true,
+ *   ];
  * ```
  *
- * There are two styling bindings in the code above and they both write
- * to the `width` property. When styling is flushed on the element, the
- * algorithm will try and figure out which one of these values to write
- * to the element.
- *
- * In order to figure out which value to apply, the following
- * binding prioritization is adhered to:
- *
- *   1. First template-level styling bindings are applied (if present).
- *      This includes things like `[style.width]` and `[class.active]`.
- *
- *   2. Second are styling-level host bindings present in directives.
- *      (if there are sub/super directives present then the sub directives
- *      are applied first).
- *
- *   3. Third are styling-level host bindings present in components.
- *      (if there are sub/super components present then the sub directives
- *      are applied first).
- *
- * This means that in the code above the styling binding present in the
- * template is applied first and, only if its falsy, then the directive
- * styling binding for width will be applied.
- *
- * ### What about map-based styling bindings?
- * Map-based styling bindings are activated when there are one or more
- * `[style]` and/or `[class]` bindings present on an element. When this
- * code is activated, the apply algorithm will iterate over each map
- * entry and apply each styling value to the element with the same
- * prioritization rules as above.
- *
- * For the algorithm to apply styling values efficiently, the
- * styling map entries must be applied in sync (property by property)
- * with prop-based bindings. (The map-based algorithm is described
- * more inside of the `render3/styling/map_based_bindings.ts` file.)
- *
- * ## Sanitization
- * Sanitization is used to prevent invalid style values from being applied to
- * the element.
- *
- * It is enabled in two cases:
- *
- *   1. The `styleSanitizer(sanitizerFn)` instruction was called (just before any other
- *      styling instructions are run).
- *
- *   2. The component/directive `LView` instance has a sanitizer object attached to it
- *      (this happens when `renderComponent` is executed with a `sanitizer` value or
- *      if the ngModule contains a sanitizer provider attached to it).
+ * This means that it is safe to add class.
+ * @record
+ */
+export function TStylingStatic() { }
+/**
+ * This is a branded number which contains previous and next index.
  *
- * If and when sanitization is active then all property/value entries will be evaluated
- * through the active sanitizer before they are applied to the element (or the styling
- * debug handler).
+ * When we come across styling instructions we need to store the `TStylingKey` in the correct
+ * order so that we can re-concatenate the styling value in the desired priority.
  *
- * If a `Sanitizer` object is used (via the `LView[SANITIZER]` value) then that object
- * will be used for every property.
+ * The insertion can happen either at the:
+ * - end of template as in the case of coming across additional styling instruction in the template
+ * - in front of the template in the case of coming across additional instruction in the
+ *   `hostBindings`.
  *
- * If a `StyleSanitizerFn` function is used (via the `styleSanitizer`) then it will be
- * called in two ways:
+ * We use `TStylingRange` to store the previous and next index into the `TData` where the template
+ * bindings can be found.
  *
- *   1. property validation mode: this will be called early to mark whether a property
- *      should be sanitized or not at during the flushing stage.
+ * - bit 0 is used to mark that the previous index has a duplicate for current value.
+ * - bit 1 is used to mark that the next index has a duplicate for the current value.
+ * - bits 2-16 are used to encode the next/tail of the template.
+ * - bits 17-32 are used to encode the previous/head of template.
  *
- *   2. value sanitization mode: this will be called during the flushing stage and will
- *      run the sanitizer function against the value before applying it to the element.
+ * NODE: *duplicate* false implies that it is statically known that this binding will not collide
+ * with other bindings and therefore there is no need to check other bindings. For example the
+ * bindings in `<div [style.color]="exp" [style.width]="exp">` will never collide and will have
+ * their bits set accordingly. Previous duplicate means that we may need to check previous if the
+ * current binding is `null`. Next duplicate means that we may need to check next bindings if the
+ * current binding is not `null`.
  *
- * If sanitization returns an empty value then that empty value will be applied
- * to the element.
+ * NOTE: `0` has special significance and represents `null` as in no additional pointer.
  * @record
  */
-export function TStylingContext() { }
+export function TStylingRange() { }
 if (false) {
-    /* Skipping unnamed member:
-    [TStylingContextIndex.TotalSourcesPosition]: number;*/
-    /* Skipping unnamed member:
-    [TStylingContextIndex.InitialStylingValuePosition]: StylingMapArray;*/
+    /** @type {?} */
+    TStylingRange.prototype.__brand__;
 }
 /** @enum {number} */
-const TStylingContextIndex = {
-    TotalSourcesPosition: 0,
-    InitialStylingValuePosition: 1,
-    ValuesStartPosition: 2,
-    // each tuple entry in the context
-    // (config, templateBitGuard, hostBindingBitGuard, prop, ...bindings||default-value)
-    ConfigOffset: 0,
-    TemplateBitGuardOffset: 1,
-    HostBindingsBitGuardOffset: 2,
-    PropOffset: 3,
-    BindingsStartOffset: 4,
+const StylingRange = {
+    /// Number of bits to shift for the previous pointer
+    PREV_SHIFT: 17,
+    /// Previous pointer mask.
+    PREV_MASK: 4294836224,
+    /// Number of bits to shift for the next pointer
+    NEXT_SHIFT: 2,
+    /// Next pointer mask.
+    NEXT_MASK: 131068,
+    // Mask to remove nagative bit. (interpret number as positive)
+    UNSIGNED_MASK: 32767,
+    /**
+     * This bit is set if the previous bindings contains a binding which could possibly cause a
+     * duplicate. For example: `<div [style]="map" [style.width]="width">`, the `width` binding will
+     * have previous duplicate set. The implication is that if `width` binding becomes `null`, it is
+     * necessary to defer the value to `map.width`. (Because `width` overwrites `map.width`.)
+     */
+    PREV_DUPLICATE: 2,
+    /**
+     * This bit is set to if the next binding contains a binding which could possibly cause a
+     * duplicate. For example: `<div [style]="map" [style.width]="width">`, the `map` binding will
+     * have next duplicate set. The implication is that if `map.width` binding becomes not `null`, it
+     * is necessary to defer the value to `width`. (Because `width` overwrites `map.width`.)
+     */
+    NEXT_DUPLICATE: 1,
 };
-export { TStylingContextIndex };
-/** @enum {number} */
-const TStylingContextPropConfigFlags = {
-    Default: 0,
-    SanitizationRequired: 1,
-    TotalBits: 1,
-    Mask: 1,
-};
-export { TStylingContextPropConfigFlags };
+export { StylingRange };
 /**
- * A function used to apply or remove styling from an element for a given property.
- * @record
+ * @param {?} prev
+ * @param {?} next
+ * @return {?}
  */
-export function ApplyStylingFn() { }
+export function toTStylingRange(prev, next) {
+    ngDevMode && assertNumberInRange(prev, 0, 32767 /* UNSIGNED_MASK */);
+    ngDevMode && assertNumberInRange(next, 0, 32767 /* UNSIGNED_MASK */);
+    return (/** @type {?} */ ((prev << 17 /* PREV_SHIFT */ | next << 2 /* NEXT_SHIFT */)));
+}
 /**
- * Array-based representation of a key/value array.
- *
- * The format of the array is "property", "value", "property2",
- * "value2", etc...
- *
- * The first value in the array is reserved to store the instance
- * of the key/value array that was used to populate the property/
- * value entries that take place in the remainder of the array.
- * @record
+ * @param {?} tStylingRange
+ * @return {?}
  */
-export function StylingMapArray() { }
-if (false) {
-    /* Skipping unnamed member:
-    [StylingMapArrayIndex.RawValuePosition]: {}|string|number|null|undefined;*/
+export function getTStylingRangePrev(tStylingRange) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    return (((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) >> 17 /* PREV_SHIFT */) & 32767 /* UNSIGNED_MASK */;
 }
-/** @enum {number} */
-const StylingMapArrayIndex = {
-    /** Where the values start in the array */
-    ValuesStartPosition: 1,
-    /** The location of the raw key/value map instance used last to populate the array entries */
-    RawValuePosition: 0,
-    /** The size of each property/value entry */
-    TupleSize: 2,
-    /** The offset for the property entry in the tuple */
-    PropOffset: 0,
-    /** The offset for the value entry in the tuple */
-    ValueOffset: 1,
-};
-export { StylingMapArrayIndex };
 /**
- * Used to apply/traverse across all map-based styling entries up to the provided `targetProp`
- * value.
- *
- * When called, each of the map-based `StylingMapArray` entries (which are stored in
- * the provided `LStylingData` array) will be iterated over. Depending on the provided
- * `mode` value, each prop/value entry may be applied or skipped over.
- *
- * If `targetProp` value is provided the iteration code will stop once it reaches
- * the property (if found). Otherwise if the target property is not encountered then
- * it will stop once it reaches the next value that appears alphabetically after it.
- *
- * If a `defaultValue` is provided then it will be applied to the element only if the
- * `targetProp` property value is encountered and the value associated with the target
- * property is `null`. The reason why the `defaultValue` is needed is to avoid having the
- * algorithm apply a `null` value and then apply a default value afterwards (this would
- * end up being two style property writes).
- *
- * @return whether or not the target property was reached and its value was
- *  applied to the element.
- * @record
+ * @param {?} tStylingRange
+ * @return {?}
  */
-export function SyncStylingMapsFn() { }
-/** @enum {number} */
-const StylingMapsSyncMode = {
-    /** Only traverse values (no prop/value styling entries get applied) */
-    TraverseValues: 0,
-    /** Apply every prop/value styling entry to the element */
-    ApplyAllValues: 1,
-    /** Only apply the target prop/value entry */
-    ApplyTargetProp: 2,
-    /** Skip applying the target prop/value entry */
-    SkipTargetProp: 4,
-    /** Iterate over inner maps map values in the context */
-    RecurseInnerMaps: 8,
-    /** Only check to see if a value was set somewhere in each map */
-    CheckValuesOnly: 16,
-};
-export { StylingMapsSyncMode };
+export function getTStylingRangePrevDuplicate(tStylingRange) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    return (((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) & 2 /* PREV_DUPLICATE */) ==
+        2 /* PREV_DUPLICATE */;
+}
 /**
- * Simplified `TNode` interface for styling-related code.
- *
- * The styling algorithm code only needs access to `flags`.
- * @record
+ * @param {?} tStylingRange
+ * @param {?} previous
+ * @return {?}
  */
-export function TStylingNode() { }
-if (false) {
+export function setTStylingRangePrev(tStylingRange, previous) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    ngDevMode && assertNumberInRange(previous, 0, 32767 /* UNSIGNED_MASK */);
+    return (/** @type {?} */ (((((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) & ~4294836224 /* PREV_MASK */) |
+        (previous << 17 /* PREV_SHIFT */))));
+}
+/**
+ * @param {?} tStylingRange
+ * @return {?}
+ */
+export function setTStylingRangePrevDuplicate(tStylingRange) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    return (/** @type {?} */ ((((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) | 2 /* PREV_DUPLICATE */)));
+}
+/**
+ * @param {?} tStylingRange
+ * @return {?}
+ */
+export function getTStylingRangeNext(tStylingRange) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    return (((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) & 131068 /* NEXT_MASK */) >> 2 /* NEXT_SHIFT */;
+}
+/**
+ * @param {?} tStylingRange
+ * @param {?} next
+ * @return {?}
+ */
+export function setTStylingRangeNext(tStylingRange, next) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    ngDevMode && assertNumberInRange(next, 0, 32767 /* UNSIGNED_MASK */);
+    return (/** @type {?} */ (((((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) & ~131068 /* NEXT_MASK */) | //
+        next << 2 /* NEXT_SHIFT */)));
+}
+/**
+ * @param {?} tStylingRange
+ * @return {?}
+ */
+export function getTStylingRangeNextDuplicate(tStylingRange) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    return (((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) & 1 /* NEXT_DUPLICATE */) ===
+        1 /* NEXT_DUPLICATE */;
+}
+/**
+ * @param {?} tStylingRange
+ * @return {?}
+ */
+export function setTStylingRangeNextDuplicate(tStylingRange) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
+    return (/** @type {?} */ ((((/** @type {?} */ ((/** @type {?} */ (tStylingRange))))) | 1 /* NEXT_DUPLICATE */)));
+}
+/**
+ * @param {?} tStylingRange
+ * @return {?}
+ */
+export function getTStylingRangeTail(tStylingRange) {
+    ngDevMode && assertNumber(tStylingRange, 'expected number');
     /** @type {?} */
-    TStylingNode.prototype.flags;
+    const next = getTStylingRangeNext(tStylingRange);
+    return next === 0 ? getTStylingRangePrev(tStylingRange) : next;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqUA,qCAOC;;;;;;;;AAKD,MAAkB,oBAAoB;IACpC,oBAAoB,GAAI;IACxB,2BAA2B,GAAI;IAC/B,mBAAmB,GAAI;IAEvB,kCAAkC;IAClC,oFAAoF;IACpF,YAAY,GAAI;IAChB,sBAAsB,GAAI;IAC1B,0BAA0B,GAAI;IAC9B,UAAU,GAAI;IACd,mBAAmB,GAAI;EACxB;;;AAKD,MAAkB,8BAA8B;IAC9C,OAAO,GAAM;IACb,oBAAoB,GAAM;IAC1B,SAAS,GAAI;IACb,IAAI,GAAM;EACX;;;;;;AAKD,oCAGC;;;;;;;;;;;;AAsBD,qCAKC;;;;;;AAKD,MAAkB,oBAAoB;IACpC,0CAA0C;IAC1C,mBAAmB,GAAI;IAEvB,6FAA6F;IAC7F,gBAAgB,GAAI;IAEpB,4CAA4C;IAC5C,SAAS,GAAI;IAEb,qDAAqD;IACrD,UAAU,GAAI;IAEd,kDAAkD;IAClD,WAAW,GAAI;EAChB;;;;;;;;;;;;;;;;;;;;;;;;AAuBD,uCAKC;;AAKD,MAAkB,mBAAmB;IACnC,uEAAuE;IACvE,cAAc,GAAQ;IAEtB,0DAA0D;IAC1D,cAAc,GAAQ;IAEtB,6CAA6C;IAC7C,eAAe,GAAQ;IAEvB,gDAAgD;IAChD,cAAc,GAAQ;IAEtB,wDAAwD;IACxD,gBAAgB,GAAS;IAEzB,iEAAiE;IACjE,eAAe,IAAU;EAC1B;;;;;;;;AAOD,kCAAoD;;;IAApB,6BAAkB","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\n\nimport {TNodeFlags} from './node';\nimport {ProceduralRenderer3, RElement, Renderer3} from './renderer';\nimport {LView} from './view';\n\n\n/**\n * --------\n *\n * This file contains the core interfaces for styling in Angular.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n\n/**\n * A static-level representation of all style or class bindings/values\n * associated with a `TNode`.\n *\n * The `TStylingContext` unites all template styling bindings (i.e.\n * `[class]` and `[style]` bindings) as well as all host-level\n * styling bindings (for components and directives) together into\n * a single manifest\n *\n * The styling context is stored on a `TNode` on and there are\n * two instances of it: one for classes and another for styles.\n *\n * ```typescript\n * tNode.styles = [ ... a context only for styles ... ];\n * tNode.classes = [ ... a context only for classes ... ];\n * ```\n *\n * The styling context is created each time there are one or more\n * styling bindings (style or class bindings) present for an element,\n * but is only created once per `TNode`.\n *\n * `tNode.styles` and `tNode.classes` can be an instance of the following:\n *\n * ```typescript\n * tNode.styles = null; // no static styling or styling bindings active\n * tNode.styles = StylingMapArray; // only static values present (e.g. `<div style=\"width:200\">`)\n * tNode.styles = TStylingContext; // one or more styling bindings present (e.g. `<div\n * [style.width]>`)\n * ```\n *\n * Both `tNode.styles` and `tNode.classes` are instantiated when anything\n * styling-related is active on an element. They are first created from\n * from the any of the element-level instructions (e.g. `element`,\n * `elementStart`, `elementHostAttrs`). When any static style/class\n * values are encountered they are registered on the `tNode.styles`\n * and `tNode.classes` data-structures. By default (when any static\n * values are encountered) the `tNode.styles` or `tNode.classes` values\n * are instances of a `StylingMapArray`. Only when style/class bindings\n * are detected then that styling map is converted into an instance of\n * `TStylingContext`.\n *\n * Due to the fact the the `TStylingContext` is stored on a `TNode`\n * this means that all data within the context is static. Instead of\n * storing actual styling binding values, the lView binding index values\n * are stored within the context. (static nature means it is more compact.)\n *\n * The code below shows a breakdown of two instances of `TStylingContext`\n * (one for `tNode.styles` and another for `tNode.classes`):\n *\n * ```typescript\n * // <div [class.active]=\"c\"  // lView binding index = 20\n * //      [style.width]=\"x\"   // lView binding index = 21\n * //      [style.height]=\"y\"> // lView binding index = 22\n * //  ...\n * // </div>\n * tNode.styles = [\n *   1,         // the total amount of sources present (only `1` b/c there are only template\n * bindings)\n *   [null],    // initial values array (an instance of `StylingMapArray`)\n *\n *   0,         // config entry for the property (see `TStylingContextPropConfigFlags`)\n *   0b010,     // template guard mask for height\n *   0,         // host bindings guard mask for height\n *   'height',  // the property name\n *   22,        // the binding location for the \"y\" binding in the lView\n *   null,      // the default value for height\n *\n *   0,         // config entry for the property (see `TStylingContextPropConfigFlags`)\n *   0b001,     // template guard mask for width\n *   0,         // host bindings guard mask for width\n *   'width',   // the property name\n *   21,        // the binding location for the \"x\" binding in the lView\n *   null,      // the default value for width\n * ];\n *\n * tNode.classes = [\n *   0,         // the context config value (see `TStylingContextConfig`)\n *   1,         // the total amount of sources present (only `1` b/c there are only template\n * bindings)\n *   [null],    // initial values array (an instance of `StylingMapArray`)\n *\n *   0,         // config entry for the property (see `TStylingContextPropConfigFlags`)\n *   0b001,     // template guard mask for width\n *   0,         // host bindings guard mask for width\n *   'active',  // the property name\n *   20,        // the binding location for the \"c\" binding in the lView\n *   null,      // the default value for the `active` class\n * ];\n * ```\n *\n * Entry value present in an entry (called a tuple) within the\n * styling context is as follows:\n *\n * ```typescript\n * context = [\n *   //...\n *   configValue,\n *   templateGuardMask,\n *   hostBindingsGuardMask,\n *   propName,\n *   ...bindingIndices...,\n *   defaultValue\n *   //...\n * ];\n * ```\n *\n * Below is a breakdown of each value:\n *\n * - **configValue**:\n *   Property-specific configuration values. The only config setting\n *   that is implemented right now is whether or not to sanitize the\n *   value.\n *\n * - **templateGuardMask**:\n *   A numeric value where each bit represents a binding index\n *   location. Each binding index location is assigned based on\n *   a local counter value that increments each time an instruction\n *   is called:\n *\n * ```\n * <div [style.width]=\"x\"   // binding index = 21 (counter index = 0)\n *      [style.height]=\"y\"> // binding index = 22 (counter index = 1)\n * ```\n *\n *   In the example code above, if the `width` value where to change\n *   then the first bit in the local bit mask value would be flipped\n *   (and the second bit for when `height`).\n *\n *   If and when there are more than 32 binding sources in the context\n *   (more than 32 `[style/class]` bindings) then the bit masking will\n *   overflow and we are left with a situation where a `-1` value will\n *   represent the bit mask. Due to the way that JavaScript handles\n *   negative values, when the bit mask is `-1` then all bits within\n *   that value will be automatically flipped (this is a quick and\n *   efficient way to flip all bits on the mask when a special kind\n *   of caching scenario occurs or when there are more than 32 bindings).\n *\n * - **hostBindingsGuardMask**:\n *   Another instance of a guard mask that is specific to host bindings.\n *   This behaves exactly the same way as does the `templateGuardMask`,\n *   but will not contain any binding information processed in the template.\n *   The reason why there are two instances of guard masks (one for the\n *   template and another for host bindings) is because the template bindings\n *   are processed before host bindings and the state information is not\n *   carried over into the host bindings code. As soon as host bindings are\n *   processed for an element the counter and state-based bit mask values are\n *   set to `0`.\n *\n * ```\n * <div [style.width]=\"x\"   // binding index = 21 (counter index = 0)\n *      [style.height]=\"y\"  // binding index = 22 (counter index = 1)\n *      dir-that-sets-width  // binding index = 30 (counter index = 0)\n *      dir-that-sets-width> // binding index = 31 (counter index = 1)\n * ```\n *\n * - **propName**:\n *   The CSS property name or class name (e.g `width` or `active`).\n *\n * - **bindingIndices...**:\n *   A series of numeric binding values that reflect where in the\n *   lView to find the style/class values associated with the property.\n *   Each value is in order in terms of priority (templates are first,\n *   then directives and then components). When the context is flushed\n *   and the style/class values are applied to the element (this happens\n *   inside of the `stylingApply` instruction) then the flushing code\n *   will keep checking each binding index against the associated lView\n *   to find the first style/class value that is non-null.\n *\n * - **defaultValue**:\n *   This is the default that will always be applied to the element if\n *   and when all other binding sources return a result that is null.\n *   Usually this value is `null` but it can also be a static value that\n *   is intercepted when the tNode is first constructured (e.g.\n *   `<div style=\"width:200px\">` has a default value of `200px` for\n *   the `width` property).\n *\n * Each time a new binding is encountered it is registered into the\n * context. The context then is continually updated until the first\n * styling apply call has been called (which is automatically scheduled\n * to be called once an element exits during change detection). Note that\n * each entry in the context is stored in alphabetical order.\n *\n * Once styling has been flushed for the first time for an element the\n * context will set as locked (this prevents bindings from being added\n * to the context later on).\n *\n * # How Styles/Classes are Rendered\n * Each time a styling instruction (e.g. `[class.name]`, `[style.prop]`,\n * etc...) is executed, the associated `lView` for the view is updated\n * at the current binding location. Also, when this happens, a local\n * counter value is incremented. If the binding value has changed then\n * a local `bitMask` variable is updated with the specific bit based\n * on the counter value.\n *\n * Below is a lightweight example of what happens when a single style\n * property is updated (i.e. `<div [style.prop]=\"val\">`):\n *\n * ```typescript\n * function updateStyleProp(prop: string, value: string) {\n *   const lView = getLView();\n *   const bindingIndex = BINDING_INDEX++;\n *\n *   // update the local counter value\n *   const indexForStyle = stylingState.stylesCount++;\n *   if (lView[bindingIndex] !== value) {\n *     lView[bindingIndex] = value;\n *\n *     // tell the local state that we have updated a style value\n *     // by updating the bit mask\n *     stylingState.bitMaskForStyles |= 1 << indexForStyle;\n *   }\n * }\n * ```\n *\n * Once all the bindings have updated a `bitMask` value will be populated.\n * This `bitMask` value is used in the apply algorithm (which is called\n * context resolution).\n *\n * ## The Apply Algorithm (Context Resolution)\n * As explained above, each time a binding updates its value, the resulting\n * value is stored in the `lView` array. These styling values have yet to\n * be flushed to the element.\n *\n * Once all the styling instructions have been evaluated, then the styling\n * context(s) are flushed to the element. When this happens, the context will\n * be iterated over (property by property) and each binding source will be\n * examined and the first non-null value will be applied to the element.\n *\n * Let's say that we the following template code:\n *\n * ```html\n * <div [style.width]=\"w1\" dir-that-set-width=\"w2\"></div>\n * ```\n *\n * There are two styling bindings in the code above and they both write\n * to the `width` property. When styling is flushed on the element, the\n * algorithm will try and figure out which one of these values to write\n * to the element.\n *\n * In order to figure out which value to apply, the following\n * binding prioritization is adhered to:\n *\n *   1. First template-level styling bindings are applied (if present).\n *      This includes things like `[style.width]` and `[class.active]`.\n *\n *   2. Second are styling-level host bindings present in directives.\n *      (if there are sub/super directives present then the sub directives\n *      are applied first).\n *\n *   3. Third are styling-level host bindings present in components.\n *      (if there are sub/super components present then the sub directives\n *      are applied first).\n *\n * This means that in the code above the styling binding present in the\n * template is applied first and, only if its falsy, then the directive\n * styling binding for width will be applied.\n *\n * ### What about map-based styling bindings?\n * Map-based styling bindings are activated when there are one or more\n * `[style]` and/or `[class]` bindings present on an element. When this\n * code is activated, the apply algorithm will iterate over each map\n * entry and apply each styling value to the element with the same\n * prioritization rules as above.\n *\n * For the algorithm to apply styling values efficiently, the\n * styling map entries must be applied in sync (property by property)\n * with prop-based bindings. (The map-based algorithm is described\n * more inside of the `render3/styling/map_based_bindings.ts` file.)\n *\n * ## Sanitization\n * Sanitization is used to prevent invalid style values from being applied to\n * the element.\n *\n * It is enabled in two cases:\n *\n *   1. The `styleSanitizer(sanitizerFn)` instruction was called (just before any other\n *      styling instructions are run).\n *\n *   2. The component/directive `LView` instance has a sanitizer object attached to it\n *      (this happens when `renderComponent` is executed with a `sanitizer` value or\n *      if the ngModule contains a sanitizer provider attached to it).\n *\n * If and when sanitization is active then all property/value entries will be evaluated\n * through the active sanitizer before they are applied to the element (or the styling\n * debug handler).\n *\n * If a `Sanitizer` object is used (via the `LView[SANITIZER]` value) then that object\n * will be used for every property.\n *\n * If a `StyleSanitizerFn` function is used (via the `styleSanitizer`) then it will be\n * called in two ways:\n *\n *   1. property validation mode: this will be called early to mark whether a property\n *      should be sanitized or not at during the flushing stage.\n *\n *   2. value sanitization mode: this will be called during the flushing stage and will\n *      run the sanitizer function against the value before applying it to the element.\n *\n * If sanitization returns an empty value then that empty value will be applied\n * to the element.\n */\nexport interface TStylingContext extends\n    Array<number|string|number|boolean|null|StylingMapArray|{}> {\n  /** The total amount of sources present in the context */\n  [TStylingContextIndex.TotalSourcesPosition]: number;\n\n  /** Initial value position for static styles */\n  [TStylingContextIndex.InitialStylingValuePosition]: StylingMapArray;\n}\n\n/**\n * An index of position and offset values used to navigate the `TStylingContext`.\n */\nexport const enum TStylingContextIndex {\n  TotalSourcesPosition = 0,\n  InitialStylingValuePosition = 1,\n  ValuesStartPosition = 2,\n\n  // each tuple entry in the context\n  // (config, templateBitGuard, hostBindingBitGuard, prop, ...bindings||default-value)\n  ConfigOffset = 0,\n  TemplateBitGuardOffset = 1,\n  HostBindingsBitGuardOffset = 2,\n  PropOffset = 3,\n  BindingsStartOffset = 4\n}\n\n/**\n * A series of flags used for each property entry within the `TStylingContext`.\n */\nexport const enum TStylingContextPropConfigFlags {\n  Default = 0b0,\n  SanitizationRequired = 0b1,\n  TotalBits = 1,\n  Mask = 0b1,\n}\n\n/**\n * A function used to apply or remove styling from an element for a given property.\n */\nexport interface ApplyStylingFn {\n  (renderer: Renderer3|ProceduralRenderer3|null, element: RElement, prop: string, value: any,\n   bindingIndex?: number|null): void;\n}\n\n/**\n * Runtime data type that is used to store binding data referenced from the `TStylingContext`.\n *\n * Because `LView` is just an array with data, there is no reason to\n * special case `LView` everywhere in the styling algorithm. By allowing\n * this data type to be an array that contains various scalar data types,\n * an instance of `LView` doesn't need to be constructed for tests.\n */\nexport type LStylingData = LView | (string | number | boolean | null)[];\n\n/**\n * Array-based representation of a key/value array.\n *\n * The format of the array is \"property\", \"value\", \"property2\",\n * \"value2\", etc...\n *\n * The first value in the array is reserved to store the instance\n * of the key/value array that was used to populate the property/\n * value entries that take place in the remainder of the array.\n */\nexport interface StylingMapArray extends Array<{}|string|number|null|undefined> {\n  /**\n   * The last raw value used to generate the entries in the map.\n   */\n  [StylingMapArrayIndex.RawValuePosition]: {}|string|number|null|undefined;\n}\n\n/**\n * An index of position and offset points for any data stored within a `StylingMapArray` instance.\n */\nexport const enum StylingMapArrayIndex {\n  /** Where the values start in the array */\n  ValuesStartPosition = 1,\n\n  /** The location of the raw key/value map instance used last to populate the array entries */\n  RawValuePosition = 0,\n\n  /** The size of each property/value entry */\n  TupleSize = 2,\n\n  /** The offset for the property entry in the tuple */\n  PropOffset = 0,\n\n  /** The offset for the value entry in the tuple */\n  ValueOffset = 1,\n}\n\n/**\n * Used to apply/traverse across all map-based styling entries up to the provided `targetProp`\n * value.\n *\n * When called, each of the map-based `StylingMapArray` entries (which are stored in\n * the provided `LStylingData` array) will be iterated over. Depending on the provided\n * `mode` value, each prop/value entry may be applied or skipped over.\n *\n * If `targetProp` value is provided the iteration code will stop once it reaches\n * the property (if found). Otherwise if the target property is not encountered then\n * it will stop once it reaches the next value that appears alphabetically after it.\n *\n * If a `defaultValue` is provided then it will be applied to the element only if the\n * `targetProp` property value is encountered and the value associated with the target\n * property is `null`. The reason why the `defaultValue` is needed is to avoid having the\n * algorithm apply a `null` value and then apply a default value afterwards (this would\n * end up being two style property writes).\n *\n * @returns whether or not the target property was reached and its value was\n *  applied to the element.\n */\nexport interface SyncStylingMapsFn {\n  (context: TStylingContext, renderer: Renderer3|ProceduralRenderer3|null, element: RElement,\n   data: LStylingData, sourceIndex: number, applyStylingFn: ApplyStylingFn,\n   sanitizer: StyleSanitizeFn|null, mode: StylingMapsSyncMode, targetProp?: string|null,\n   defaultValue?: boolean|string|null): boolean;\n}\n\n/**\n * Used to direct how map-based values are applied/traversed when styling is flushed.\n */\nexport const enum StylingMapsSyncMode {\n  /** Only traverse values (no prop/value styling entries get applied) */\n  TraverseValues = 0b000,\n\n  /** Apply every prop/value styling entry to the element */\n  ApplyAllValues = 0b001,\n\n  /** Only apply the target prop/value entry */\n  ApplyTargetProp = 0b010,\n\n  /** Skip applying the target prop/value entry */\n  SkipTargetProp = 0b100,\n\n  /** Iterate over inner maps map values in the context */\n  RecurseInnerMaps = 0b1000,\n\n  /** Only check to see if a value was set somewhere in each map */\n  CheckValuesOnly = 0b10000,\n}\n\n/**\n * Simplified `TNode` interface for styling-related code.\n *\n * The styling algorithm code only needs access to `flags`.\n */\nexport interface TStylingNode { flags: TNodeFlags; }\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/styling.ts"],"names":[],"mappings":";;;;;;;;;;;;AASA,OAAO,EAAC,YAAY,EAAE,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFpE,oCAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B7D,mCAA8D;;;IAA7B,kCAA2B;;;AAK5D,MAAkB,YAAY;IAC5B,oDAAoD;IACpD,UAAU,IAAK;IACf,0BAA0B;IAC1B,SAAS,YAAa;IAEtB,gDAAgD;IAChD,UAAU,GAAI;IACd,sBAAsB;IACtB,SAAS,QAAY;IAErB,8DAA8D;IAC9D,aAAa,OAAS;IAEtB;;;;;OAKG;IACH,cAAc,GAAO;IAErB;;;;;OAKG;IACH,cAAc,GAAO;EACtB;;;;;;;AAGD,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,IAAY;IACxD,SAAS,IAAI,mBAAmB,CAAC,IAAI,EAAE,CAAC,4BAA6B,CAAC;IACtE,SAAS,IAAI,mBAAmB,CAAC,IAAI,EAAE,CAAC,4BAA6B,CAAC;IACtE,OAAO,mBAAA,CAAC,IAAI,uBAA2B,GAAG,IAAI,sBAA2B,CAAC,EAAO,CAAC;AACpF,CAAC;;;;;AAED,MAAM,UAAU,oBAAoB,CAAC,aAA4B;IAC/D,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,OAAO,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,uBAA2B,CAAC,4BAA6B,CAAC;AACpG,CAAC;;;;;AAED,MAAM,UAAU,6BAA6B,CAAC,aAA4B;IACxE,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,OAAO,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,yBAA8B,CAAC;8BACxC,CAAC;AAClC,CAAC;;;;;;AAED,MAAM,UAAU,oBAAoB,CAChC,aAA4B,EAAE,QAAgB;IAChD,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,SAAS,IAAI,mBAAmB,CAAC,QAAQ,EAAE,CAAC,4BAA6B,CAAC;IAC1E,OAAO,mBAAA,CACH,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,GAAG,2BAAuB,CAAC;QAC5D,CAAC,QAAQ,uBAA2B,CAAC,CAAC,EAAO,CAAC;AACpD,CAAC;;;;;AAED,MAAM,UAAU,6BAA6B,CAAC,aAA4B;IACxE,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,OAAO,mBAAA,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,yBAA8B,CAAC,EAAO,CAAC;AACjF,CAAC;;;;;AAED,MAAM,UAAU,oBAAoB,CAAC,aAA4B;IAC/D,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,OAAO,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,yBAAyB,CAAC,sBAA2B,CAAC;AAChG,CAAC;;;;;;AAED,MAAM,UAAU,oBAAoB,CAAC,aAA4B,EAAE,IAAY;IAC7E,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,SAAS,IAAI,mBAAmB,CAAC,IAAI,EAAE,CAAC,4BAA6B,CAAC;IACtE,OAAO,mBAAA,CACH,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,GAAG,uBAAuB,CAAC,GAAI,EAAE;QAClE,IAAI,sBAA2B,CAAC,EAAO,CAAC;AAC9C,CAAC;;;;;AAED,MAAM,UAAU,6BAA6B,CAAC,aAA4B;IACxE,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,OAAO,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,yBAA8B,CAAC;8BACxC,CAAC;AAClC,CAAC;;;;;AAED,MAAM,UAAU,6BAA6B,CAAC,aAA4B;IACxE,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5D,OAAO,mBAAA,CAAC,CAAC,mBAAA,mBAAA,aAAa,EAAO,EAAU,CAAC,yBAA8B,CAAC,EAAO,CAAC;AACjF,CAAC;;;;;AAED,MAAM,UAAU,oBAAoB,CAAC,aAA4B;IAC/D,SAAS,IAAI,YAAY,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;;UACtD,IAAI,GAAG,oBAAoB,CAAC,aAAa,CAAC;IAChD,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACjE,CAAC","sourcesContent":["/**\n* @license\n* Copyright Google Inc. All Rights Reserved.\n*\n* Use of this source code is governed by an MIT-style license that can be\n* found in the LICENSE file at https://angular.io/license\n*/\n\nimport {KeyValueArray} from '../../util/array_utils';\nimport {assertNumber, assertNumberInRange} from '../../util/assert';\n\n/**\n * Value stored in the `TData` which is needed to re-concatenate the styling.\n *\n * See: `TStylingKeyPrimitive` and `TStylingStatic`\n */\nexport type TStylingKey = TStylingKeyPrimitive | TStylingStatic;\n\n\n/**\n * The primitive portion (`TStylingStatic` removed) of the value stored in the `TData` which is\n * needed to re-concatenate the styling.\n *\n * - `string`: Stores the property name. Used with `ɵɵstyleProp`/`ɵɵclassProp` instruction.\n * - `null`: Represents map, so there is no name. Used with `ɵɵstyleMap`/`ɵɵclassMap`.\n * - `false`: Represents an ignore case. This happens when `ɵɵstyleProp`/`ɵɵclassProp` instruction\n *   is combined with directive which shadows its input `@Input('class')`. That way the binding\n *   should not participate in the styling resolution.\n */\nexport type TStylingKeyPrimitive = string | null | false;\n\n/**\n * Store the static values for the styling binding.\n *\n * The `TStylingStatic` is just `KeyValueArray` where key `\"\"` (stored at location 0) contains the\n * `TStylingKey` (stored at location 1). In other words this wraps the `TStylingKey` such that the\n * `\"\"` contains the wrapped value.\n *\n * When instructions are resolving styling they may need to look forward or backwards in the linked\n * list to resolve the value. For this reason we have to make sure that he linked list also contains\n * the static values. However the list only has space for one item per styling instruction. For this\n * reason we store the static values here as part of the `TStylingKey`. This means that the\n * resolution function when looking for a value needs to first look at the binding value, and than\n * at `TStylingKey` (if it exists).\n *\n * Imagine we have:\n *\n * ```\n * <div class=\"TEMPLATE\" my-dir>\n *\n * @Directive({\n *   host: {\n *     class: 'DIR',\n *     '[class.dynamic]': 'exp' // ɵɵclassProp('dynamic', ctx.exp);\n *   }\n * })\n * ```\n *\n * In the above case the linked list will contain one item:\n *\n * ```\n *   // assume binding location: 10 for `ɵɵclassProp('dynamic', ctx.exp);`\n *   tData[10] = <TStylingStatic>[\n *     '': 'dynamic', // This is the wrapped value of `TStylingKey`\n *     'DIR': true,   // This is the default static value of directive binding.\n *   ];\n *   tData[10 + 1] = 0; // We don't have prev/next.\n *\n *   lView[10] = undefined;     // assume `ctx.exp` is `undefined`\n *   lView[10 + 1] = undefined; // Just normalized `lView[10]`\n * ```\n *\n * So when the function is resolving styling value, it first needs to look into the linked list\n * (there is none) and than into the static `TStylingStatic` too see if there is a default value for\n * `dynamic` (there is not). Therefore it is safe to remove it.\n *\n * If setting `true` case:\n * ```\n *   lView[10] = true;     // assume `ctx.exp` is `true`\n *   lView[10 + 1] = true; // Just normalized `lView[10]`\n * ```\n * So when the function is resolving styling value, it first needs to look into the linked list\n * (there is none) and than into `TNode.residualClass` (TNode.residualStyle) which contains\n * ```\n *   tNode.residualClass = [\n *     'TEMPLATE': true,\n *   ];\n * ```\n *\n * This means that it is safe to add class.\n */\nexport interface TStylingStatic extends KeyValueArray<any> {}\n\n/**\n * This is a branded number which contains previous and next index.\n *\n * When we come across styling instructions we need to store the `TStylingKey` in the correct\n * order so that we can re-concatenate the styling value in the desired priority.\n *\n * The insertion can happen either at the:\n * - end of template as in the case of coming across additional styling instruction in the template\n * - in front of the template in the case of coming across additional instruction in the\n *   `hostBindings`.\n *\n * We use `TStylingRange` to store the previous and next index into the `TData` where the template\n * bindings can be found.\n *\n * - bit 0 is used to mark that the previous index has a duplicate for current value.\n * - bit 1 is used to mark that the next index has a duplicate for the current value.\n * - bits 2-16 are used to encode the next/tail of the template.\n * - bits 17-32 are used to encode the previous/head of template.\n *\n * NODE: *duplicate* false implies that it is statically known that this binding will not collide\n * with other bindings and therefore there is no need to check other bindings. For example the\n * bindings in `<div [style.color]=\"exp\" [style.width]=\"exp\">` will never collide and will have\n * their bits set accordingly. Previous duplicate means that we may need to check previous if the\n * current binding is `null`. Next duplicate means that we may need to check next bindings if the\n * current binding is not `null`.\n *\n * NOTE: `0` has special significance and represents `null` as in no additional pointer.\n */\nexport interface TStylingRange { __brand__: 'TStylingRange'; }\n\n/**\n * Shift and masks constants for encoding two numbers into and duplicate info into a single number.\n */\nexport const enum StylingRange {\n  /// Number of bits to shift for the previous pointer\n  PREV_SHIFT = 17,\n  /// Previous pointer mask.\n  PREV_MASK = 0xFFFE0000,\n\n  /// Number of bits to shift for the next pointer\n  NEXT_SHIFT = 2,\n  /// Next pointer mask.\n  NEXT_MASK = 0x001FFFC,\n\n  // Mask to remove nagative bit. (interpret number as positive)\n  UNSIGNED_MASK = 0x7FFF,\n\n  /**\n   * This bit is set if the previous bindings contains a binding which could possibly cause a\n   * duplicate. For example: `<div [style]=\"map\" [style.width]=\"width\">`, the `width` binding will\n   * have previous duplicate set. The implication is that if `width` binding becomes `null`, it is\n   * necessary to defer the value to `map.width`. (Because `width` overwrites `map.width`.)\n   */\n  PREV_DUPLICATE = 0x02,\n\n  /**\n   * This bit is set to if the next binding contains a binding which could possibly cause a\n   * duplicate. For example: `<div [style]=\"map\" [style.width]=\"width\">`, the `map` binding will\n   * have next duplicate set. The implication is that if `map.width` binding becomes not `null`, it\n   * is necessary to defer the value to `width`. (Because `width` overwrites `map.width`.)\n   */\n  NEXT_DUPLICATE = 0x01,\n}\n\n\nexport function toTStylingRange(prev: number, next: number): TStylingRange {\n  ngDevMode && assertNumberInRange(prev, 0, StylingRange.UNSIGNED_MASK);\n  ngDevMode && assertNumberInRange(next, 0, StylingRange.UNSIGNED_MASK);\n  return (prev << StylingRange.PREV_SHIFT | next << StylingRange.NEXT_SHIFT) as any;\n}\n\nexport function getTStylingRangePrev(tStylingRange: TStylingRange): number {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  return ((tStylingRange as any as number) >> StylingRange.PREV_SHIFT) & StylingRange.UNSIGNED_MASK;\n}\n\nexport function getTStylingRangePrevDuplicate(tStylingRange: TStylingRange): boolean {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  return ((tStylingRange as any as number) & StylingRange.PREV_DUPLICATE) ==\n      StylingRange.PREV_DUPLICATE;\n}\n\nexport function setTStylingRangePrev(\n    tStylingRange: TStylingRange, previous: number): TStylingRange {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  ngDevMode && assertNumberInRange(previous, 0, StylingRange.UNSIGNED_MASK);\n  return (\n      ((tStylingRange as any as number) & ~StylingRange.PREV_MASK) |\n      (previous << StylingRange.PREV_SHIFT)) as any;\n}\n\nexport function setTStylingRangePrevDuplicate(tStylingRange: TStylingRange): TStylingRange {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  return ((tStylingRange as any as number) | StylingRange.PREV_DUPLICATE) as any;\n}\n\nexport function getTStylingRangeNext(tStylingRange: TStylingRange): number {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  return ((tStylingRange as any as number) & StylingRange.NEXT_MASK) >> StylingRange.NEXT_SHIFT;\n}\n\nexport function setTStylingRangeNext(tStylingRange: TStylingRange, next: number): TStylingRange {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  ngDevMode && assertNumberInRange(next, 0, StylingRange.UNSIGNED_MASK);\n  return (\n      ((tStylingRange as any as number) & ~StylingRange.NEXT_MASK) |  //\n      next << StylingRange.NEXT_SHIFT) as any;\n}\n\nexport function getTStylingRangeNextDuplicate(tStylingRange: TStylingRange): boolean {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  return ((tStylingRange as any as number) & StylingRange.NEXT_DUPLICATE) ===\n      StylingRange.NEXT_DUPLICATE;\n}\n\nexport function setTStylingRangeNextDuplicate(tStylingRange: TStylingRange): TStylingRange {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  return ((tStylingRange as any as number) | StylingRange.NEXT_DUPLICATE) as any;\n}\n\nexport function getTStylingRangeTail(tStylingRange: TStylingRange): number {\n  ngDevMode && assertNumber(tStylingRange, 'expected number');\n  const next = getTStylingRangeNext(tStylingRange);\n  return next === 0 ? getTStylingRangePrev(tStylingRange) : next;\n}"]}