@angular/core 7.0.0-rc.1 → 7.0.3

package/src/render3/interfaces/i18n.d.ts

@@ -0,0 +1,326 @@
+/**
+ * @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
+ */
+/**
+ * `I18nMutateOpCode` defines OpCodes for `I18nMutateOpCodes` array.
+ *
+ * OpCodes contain three parts:
+ *  1) Parent node index offset.
+ *  2) Reference node index offset.
+ *  3) The OpCode to execute.
+ *
+ * See: `I18nCreateOpCodes` for example of usage.
+ */
+export declare const enum I18nMutateOpCode {
+    SHIFT_REF = 2,
+    SHIFT_PARENT = 17,
+    MASK_OPCODE = 3,
+    MASK_REF = 68,
+    Select = 0,
+    AppendChild = 1,
+    InsertBefore = 2,
+    Remove = 3
+}
+/**
+ * Marks that the next string is for element.
+ *
+ * See `I18nMutateOpCodes` documentation.
+ */
+export declare const ELEMENT_MARKER: ELEMENT_MARKER;
+export interface ELEMENT_MARKER {
+    marker: 'element';
+}
+/**
+ * Marks that the next string is for comment.
+ *
+ * See `I18nMutateOpCodes` documentation.
+ */
+export declare const COMMENT_MARKER: COMMENT_MARKER;
+export interface COMMENT_MARKER {
+    marker: 'comment';
+}
+/**
+ * Array storing OpCode for dynamically creating `i18n` blocks.
+ *
+ * Example:
+ * ```
+ * <I18nCreateOpCode>[
+ *   // For adding text nodes
+ *   // ---------------------
+ *   // Equivalent to:
+ *   //   const node = lViewData[index++] = document.createTextNode('abc');
+ *   //   lViewData[1].insertBefore(node, lViewData[2]);
+ *   'abc', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,
+ *
+ *   // Equivalent to:
+ *   //   const node = lViewData[index++] = document.createTextNode('xyz');
+ *   //   lViewData[1].appendChild(node);
+ *   'xyz', 1 << SHIFT_PARENT | AppendChild,
+ *
+ *   // For adding element nodes
+ *   // ---------------------
+ *   // Equivalent to:
+ *   //   const node = lViewData[index++] = document.createElement('div');
+ *   //   lViewData[1].insertBefore(node, lViewData[2]);
+ *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,
+ *
+ *   // Equivalent to:
+ *   //   const node = lViewData[index++] = document.createElement('div');
+ *   //   lViewData[1].appendChild(node);
+ *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | AppendChild,
+ *
+ *   // For adding comment nodes
+ *   // ---------------------
+ *   // Equivalent to:
+ *   //   const node = lViewData[index++] = document.createComment('');
+ *   //   lViewData[1].insertBefore(node, lViewData[2]);
+ *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,
+ *
+ *   // Equivalent to:
+ *   //   const node = lViewData[index++] = document.createComment('');
+ *   //   lViewData[1].appendChild(node);
+ *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | AppendChild,
+ *
+ *   // For moving existing nodes to a different location
+ *   // --------------------------------------------------
+ *   // Equivalent to:
+ *   //   const node = lViewData[1];
+ *   //   lViewData[2].insertBefore(node, lViewData[3]);
+ *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | 3 << SHIFT_REF | InsertBefore,
+ *
+ *   // Equivalent to:
+ *   //   const node = lViewData[1];
+ *   //   lViewData[2].appendChild(node);
+ *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | AppendChild,
+ *
+ *   // For removing existing nodes
+ *   // --------------------------------------------------
+ *   //   const node = lViewData[1];
+ *   //   lViewData[2].remove(node);
+ *   2 << SHIFT_PARENT | 1 << SHIFT_REF | Remove,
+ *
+ *   // For writing attributes
+ *   // --------------------------------------------------
+ *   //   const node = lViewData[1];
+ *   //   node.setAttribute('attr', 'value');
+ *   1 << SHIFT_REF | Select, 'attr', 'value'
+ *            // NOTE: Select followed by two string (vs select followed by OpCode)
+ * ];
+ * ```
+ * NOTE:
+ *   - `index` is initial location where the extra nodes should be stored in the EXPANDO section of
+ * `LVIewData`.
+ *
+ * See: `applyI18nCreateOpCodes`;
+ */
+export interface I18nMutateOpCodes extends Array<number | string | ELEMENT_MARKER | COMMENT_MARKER | null> {
+}
+export declare const enum I18nUpdateOpCode {
+    SHIFT_REF = 2,
+    SHIFT_ICU = 17,
+    MASK_OPCODE = 3,
+    MASK_REF = 68,
+    Text = 0,
+    Attr = 1,
+    IcuSwitch = 2,
+    IcuUpdate = 3
+}
+/**
+ * Stores DOM operations which need to be applied to update DOM render tree due to changes in
+ * expressions.
+ *
+ * The basic idea is that `i18nExp` OpCodes capture expression changes and update a change
+ * mask bit. (Bit 1 for expression 1, bit 2 for expression 2 etc..., bit 32 for expression 32 and
+ * higher.) The OpCodes then compare its own change mask against the expression change mask to
+ * determine if the OpCodes should execute.
+ *
+ * These OpCodes can be used by both the i18n block as well as ICU sub-block.
+ *
+ * ## Example
+ *
+ * Assume
+ * ```
+ *   if (rf & RenderFlags.Update) {
+ *    i18nExp(bind(ctx.exp1)); // If changed set mask bit 1
+ *    i18nExp(bind(ctx.exp2)); // If changed set mask bit 2
+ *    i18nExp(bind(ctx.exp3)); // If changed set mask bit 3
+ *    i18nExp(bind(ctx.exp4)); // If changed set mask bit 4
+ *    i18nApply(0);            // Apply all changes by executing the OpCodes.
+ *  }
+ * ```
+ * We can assume that each call to `i18nExp` sets an internal `changeMask` bit depending on the
+ * index of `i18nExp` index.
+ *
+ * OpCodes
+ * ```
+ * <I18nUpdateOpCodes>[
+ *   // The following OpCodes represent: `<div i18n-title="pre{{exp1}}in{{exp2}}post">`
+ *   // If `changeMask & 0b11`
+ *   //        has changed then execute update OpCodes.
+ *   //        has NOT changed then skip `7` values and start processing next OpCodes.
+ *   0b11, 7,
+ *   // Concatenate `newValue = 'pre'+lViewData[bindIndex-4]+'in'+lViewData[bindIndex-3]+'post';`.
+ *   'pre', -4, 'in', -3, 'post',
+ *   // Update attribute: `elementAttribute(1, 'title', sanitizerFn(newValue));`
+ *   1 << SHIFT_REF | Attr, 'title', sanitizerFn,
+ *
+ *   // The following OpCodes represent: `<div i18n>Hello {{exp3}}!">`
+ *   // If `changeMask & 0b100`
+ *   //        has changed then execute update OpCodes.
+ *   //        has NOT changed then skip `4` values and start processing next OpCodes.
+ *   0b100, 4,
+ *   // Concatenate `newValue = 'Hello ' + lViewData[bindIndex -2] + '!';`.
+ *   'Hello ', -2, '!',
+ *   // Update text: `lViewData[1].textContent = newValue;`
+ *   1 << SHIFT_REF | Text,
+ *
+ *   // The following OpCodes represent: `<div i18n>{exp4, plural, ... }">`
+ *   // If `changeMask & 0b1000`
+ *   //        has changed then execute update OpCodes.
+ *   //        has NOT changed then skip `4` values and start processing next OpCodes.
+ *   0b1000, 4,
+ *   // Concatenate `newValue = lViewData[bindIndex -1];`.
+ *   -1,
+ *   // Switch ICU: `icuSwitchCase(lViewData[1], 0, newValue);`
+ *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuSwitch,
+ *
+ *   // Note `changeMask & -1` is always true, so the IcuUpdate will always execute.
+ *   -1, 1,
+ *   // Update ICU: `icuUpdateCase(lViewData[1], 0);`
+ *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuUpdate,
+ *
+ * ];
+ * ```
+ *
+ */
+export interface I18nUpdateOpCodes extends Array<string | number | ((text: string) => string | null)> {
+}
+/**
+ * Store information for the i18n translation block.
+ */
+export interface TI18n {
+    /**
+     * Number of slots to allocate in expando.
+     *
+     * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When
+     * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can
+     * write into them.
+     */
+    vars: number;
+    /**
+     * Index in EXPANDO where the i18n stores its DOM nodes.
+     *
+     * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the
+     * newly created DOM nodes will be inserted.
+     */
+    expandoStartIndex: number;
+    /**
+     * A set of OpCodes which will create the Text Nodes and ICU anchors for the translation blocks.
+     *
+     * NOTE: The ICU anchors are filled in with ICU Update OpCode.
+     */
+    create: I18nMutateOpCodes;
+    /**
+     * A set of OpCodes which will be executed on each change detection to determine if any changes to
+     * DOM are required.
+     */
+    update: I18nUpdateOpCodes;
+    /**
+     * A list of ICUs in a translation block (or `null` if block has no ICUs).
+     *
+     * Example:
+     * Given: `<div i18n>You have {count, plural, ...} and {state, switch, ...}</div>`
+     * There would be 2 ICUs in this array.
+     *   1. `{count, plural, ...}`
+     *   2. `{state, switch, ...}`
+     */
+    icus: TIcu[] | null;
+}
+/**
+ * Defines the ICU type of `select` or `plural`
+ */
+export declare const enum IcuType {
+    select = 0,
+    plural = 1
+}
+export interface TIcu {
+    /**
+     * Defines the ICU type of `select` or `plural`
+     */
+    type: IcuType;
+    /**
+     * Number of slots to allocate in expando for each case.
+     *
+     * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When
+     * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can
+     * write into them.
+     */
+    vars: number[];
+    /**
+     * An optional array of child/sub ICUs.
+     *
+     * In case of nested ICUs such as:
+     * ```
+     * {�0�, plural,
+     *   =0 {zero}
+     *   other {�0� {�1�, select,
+     *                     cat {cats}
+     *                     dog {dogs}
+     *                     other {animals}
+     *                   }!
+     *   }
+     * }
+     * ```
+     * When the parent ICU is changing it must clean up child ICUs as well. For this reason it needs
+     * to know which child ICUs to run clean up for as well.
+     *
+     * In the above example this would be:
+     * ```
+     * [
+     *   [],   // `=0` has no sub ICUs
+     *   [1],  // `other` has one subICU at `1`st index.
+     * ]
+     * ```
+     *
+     * The reason why it is Array of Arrays is because first array represents the case, and second
+     * represents the child ICUs to clean up. There may be more than one child ICUs per case.
+     */
+    childIcus: number[][];
+    /**
+     * Index in EXPANDO where the i18n stores its DOM nodes.
+     *
+     * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the
+     * newly created DOM nodes will be inserted.
+     */
+    expandoStartIndex: number;
+    /**
+     * A list of case values which the current ICU will try to match.
+     *
+     * The last value is `other`
+     */
+    cases: any[];
+    /**
+     * A set of OpCodes to apply in order to build up the DOM render tree for the ICU
+     */
+    create: I18nMutateOpCodes[];
+    /**
+     * A set of OpCodes to apply in order to destroy the DOM render tree for the ICU.
+     */
+    remove: I18nMutateOpCodes[];
+    /**
+     * A set of OpCodes to apply in order to update the DOM render tree for the ICU bindings.
+     */
+    update: I18nUpdateOpCodes[];
+}
+/**
+ * Stores currently selected case in each ICU.
+ *
+ * For each ICU in translation, the `Li18n` stores the currently selected case for the current
+ * `LView`. For perf reasons this array is only created if a translation block has an ICU.
+ */
+export interface LI18n extends Array<number> {
+}

package/src/render3/interfaces/node.d.ts

@@ -5,13 +5,11 @@
  * 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 { LContainer } from './container';
-import { RComment, RElement, RText } from './renderer';
 import { StylingContext } from './styling';
 import { LViewData, TView } from './view';
 /**
  * TNodeType corresponds to the TNode.type property. It contains information
- * on how to map a particular set of bits in LNode.flags to the node type.
+ * on how to map a particular set of bits in TNode.flags to the node type.
  */
 export declare const enum TNodeType {
     Container = 0,
@@ -36,77 +34,6 @@ export declare const enum TNodeFlags {
     /** The index of the first directive on this node is encoded on the most significant bits  */
     DirectiveStartingIndexShift = 15
 }
-/**
- * LNode is an internal data structure which is used for the incremental DOM algorithm.
- * The "L" stands for "Logical" to differentiate between `RNodes` (actual rendered DOM
- * node) and our logical representation of DOM nodes, `LNodes`.
- *
- * The data structure is optimized for speed and size.
- *
- * In order to be fast, all subtypes of `LNode` should have the same shape.
- * Because size of the `LNode` matters, many fields have multiple roles depending
- * on the `LNode` subtype.
- *
- * See: https://en.wikipedia.org/wiki/Inline_caching#Monomorphic_inline_caching
- *
- * NOTE: This is a private data structure and should not be exported by any of the
- * instructions.
- */
-export interface LNode {
-    /**
-     * The associated DOM node. Storing this allows us to:
-     *  - append children to their element parents in the DOM (e.g. `parent.native.appendChild(...)`)
-     *  - retrieve the sibling elements of text nodes whose creation / insertion has been delayed
-     */
-    readonly native: RComment | RElement | RText | null;
-    /**
-     * If regular LElementNode, LTextNode, and LProjectionNode then `data` will be null.
-     * If LElementNode with component, then `data` contains LViewData.
-     * If LViewNode, then `data` contains the LViewData.
-     * If LContainerNode, then `data` contains LContainer.
-     */
-    readonly data: LViewData | LContainer | null;
-    /**
-     * A pointer to an LContainerNode created by directives requesting ViewContainerRef
-     */
-    dynamicLContainerNode: LContainerNode | null;
-}
-/** LNode representing an element. */
-export interface LElementNode extends LNode {
-    /** The DOM element associated with this node. */
-    readonly native: RElement;
-    /** If Component then data has LView (light DOM) */
-    readonly data: LViewData | null;
-}
-/** LNode representing <ng-container>. */
-export interface LElementContainerNode extends LNode {
-    /** The DOM comment associated with this node. */
-    readonly native: RComment;
-    readonly data: null;
-}
-/** LNode representing a #text node. */
-export interface LTextNode extends LNode {
-    /** The text node associated with this node. */
-    native: RText;
-    readonly data: null;
-    dynamicLContainerNode: null;
-}
-/** Abstract node which contains root nodes of a view. */
-export interface LViewNode extends LNode {
-    readonly native: null;
-    readonly data: LViewData;
-    dynamicLContainerNode: null;
-}
-/** Abstract node container which contains other views. */
-export interface LContainerNode extends LNode {
-    native: RComment;
-    readonly data: LContainer;
-}
-export interface LProjectionNode extends LNode {
-    readonly native: null;
-    readonly data: null;
-    dynamicLContainerNode: null;
-}
 /**
  * A set of marker values to be used in the attributes arrays. Those markers indicate that some
  * items are not regular attributes and the processing should be adapted accordingly.
@@ -133,7 +60,7 @@ export declare const enum AttributeMarker {
  */
 export declare type TAttributes = (string | AttributeMarker)[];
 /**
- * LNode binding data (flyweight) for a particular node that is shared between all templates
+ * Binding data (flyweight) for a particular node that is shared between all templates
  * of a specific type.
  *
  * If a property is:
@@ -147,9 +74,9 @@ export interface TNode {
     /** The type of the TNode. See TNodeType. */
     type: TNodeType;
     /**
-     * Index of the TNode in TView.data and corresponding LNode in LView.data.
+     * Index of the TNode in TView.data and corresponding native element in LViewData.
      *
-     * This is necessary to get from any TNode to its corresponding LNode when
+     * This is necessary to get from any TNode to its corresponding native element when
      * traversing the node tree.
      *
      * If index is -1, this is a dynamically created container node or embedded view node.
@@ -233,7 +160,7 @@ export interface TNode {
     /**
      * The TView or TViews attached to this node.
      *
-     * If this TNode corresponds to an LContainerNode with inline views, the container will
+     * If this TNode corresponds to an LContainer with inline views, the container will
      * need to store separate static data for each of its view blocks (TView[]). Otherwise,
      * nodes in inline views with the same index as nodes in their parent views will overwrite
      * each other, as they are in the same template.
@@ -245,10 +172,10 @@ export interface TNode {
      *   [{tagName: 'div', attrs: ...}, null],     // V(0) TView
      *   [{tagName: 'button', attrs ...}, null]    // V(1) TView
      *
-     * If this TNode corresponds to an LContainerNode with a template (e.g. structural
+     * If this TNode corresponds to an LContainer with a template (e.g. structural
      * directive), the template's TView will be stored here.
      *
-     * If this TNode corresponds to an LElementNode, tViews will be null .
+     * If this TNode corresponds to an element, tViews will be null .
      */
     tViews: TView | TView[] | null;
     /**
@@ -278,10 +205,6 @@ export interface TNode {
      * If this is an inline view node (V), the parent will be its container.
      */
     parent: TElementNode | TContainerNode | null;
-    /**
-     * A pointer to a TContainerNode created by directives requesting ViewContainerRef
-     */
-    dynamicContainerNode: TNode | null;
     /**
      * If this node is part of an i18n block, it indicates whether this container is part of the DOM
      * If this node is not part of an i18n block, this field is null.
@@ -326,7 +249,7 @@ export interface TNode {
      */
     projection: (TNode | null)[] | number | null;
 }
-/** Static data for an LElementNode  */
+/** Static data for an element  */
 export interface TElementNode extends TNode {
     /** Index in the data[] array */
     index: number;
@@ -345,7 +268,7 @@ export interface TElementNode extends TNode {
      */
     projection: (TNode | null)[] | null;
 }
-/** Static data for an LTextNode  */
+/** Static data for a text node */
 export interface TTextNode extends TNode {
     /** Index in the data[] array */
     index: number;
@@ -359,7 +282,7 @@ export interface TTextNode extends TNode {
     tViews: null;
     projection: null;
 }
-/** Static data for an LContainerNode */
+/** Static data for an LContainer */
 export interface TContainerNode extends TNode {
     /**
      * Index in the data[] array.
@@ -379,7 +302,7 @@ export interface TContainerNode extends TNode {
     tViews: TView | TView[] | null;
     projection: null;
 }
-/** Static data for an LElementContainerNode */
+/** Static data for an <ng-container> */
 export interface TElementContainerNode extends TNode {
     /** Index in the LViewData[] array. */
     index: number;
@@ -388,7 +311,7 @@ export interface TElementContainerNode extends TNode {
     tViews: null;
     projection: null;
 }
-/** Static data for an LViewNode  */
+/** Static data for a view  */
 export interface TViewNode extends TNode {
     /** If -1, it's a dynamically created view. Otherwise, it is the view block ID. */
     index: number;

package/src/render3/interfaces/player.d.ts

@@ -17,6 +17,43 @@ export interface Player {
     destroy(): void;
     addEventListener(state: PlayState | string, cb: (data?: any) => any): void;
 }
+export declare const enum BindingType {
+    Unset = 0,
+    Class = 2,
+    Style = 3
+}
+export interface BindingStore {
+    setValue(prop: string, value: any): void;
+}
+/**
+ * Defines the shape which produces the Player.
+ *
+ * Used to produce a player that will be placed on an element that contains
+ * styling bindings that make use of the player. This function is designed
+ * to be used with `PlayerFactory`.
+ */
+export interface PlayerFactoryBuildFn {
+    (element: HTMLElement, type: BindingType, values: {
+        [key: string]: any;
+    }, currentPlayer: Player | null): Player | null;
+}
+/**
+ * Used as a reference to build a player from a styling template binding
+ * (`[style]` and `[class]`).
+ *
+ * The `fn` function will be called once any styling-related changes are
+ * evaluated on an element and is expected to return a player that will
+ * be then run on the element.
+ *
+ * `[style]`, `[style.prop]`, `[class]` and `[class.name]` template bindings
+ * all accept a `PlayerFactory` as input and this player factories.
+ */
+export interface PlayerFactory {
+    '__brand__': 'Brand for PlayerFactory that nothing will match';
+}
+export interface PlayerBuilder extends BindingStore {
+    buildPlayer(currentPlayer: Player | null): Player | undefined | null;
+}
 /**
  * The state of a given player
  *
@@ -32,11 +69,15 @@ export declare const enum PlayState {
     Destroyed = 200
 }
 /**
- * The context that stores all active animation players present on an element.
+ * The context that stores all the active players and queued player factories present on an element.
  */
-export declare type PlayerContext = Player[];
-export declare type ComponentInstance = {};
-export declare type DirectiveInstance = {};
+export interface PlayerContext extends Array<null | number | Player | PlayerBuilder> {
+    [PlayerIndex.NonBuilderPlayersStart]: number;
+    [PlayerIndex.ClassMapPlayerBuilderPosition]: PlayerBuilder | null;
+    [PlayerIndex.ClassMapPlayerPosition]: Player | null;
+    [PlayerIndex.StyleMapPlayerBuilderPosition]: PlayerBuilder | null;
+    [PlayerIndex.StyleMapPlayerPosition]: Player | null;
+}
 /**
  * Designed to be used as an injection service to capture all animation players.
  *
@@ -55,3 +96,16 @@ export interface PlayerHandler {
      */
     queuePlayer(player: Player, context: ComponentInstance | DirectiveInstance | HTMLElement): void;
 }
+export declare const enum PlayerIndex {
+    NonBuilderPlayersStart = 0,
+    ClassMapPlayerBuilderPosition = 1,
+    ClassMapPlayerPosition = 2,
+    StyleMapPlayerBuilderPosition = 3,
+    StyleMapPlayerPosition = 4,
+    PlayerBuildersStartPosition = 1,
+    SinglePlayerBuildersStartPosition = 5,
+    PlayerAndPlayerBuildersTupleSize = 2,
+    PlayerOffsetPosition = 1
+}
+export declare type ComponentInstance = {};
+export declare type DirectiveInstance = {};

package/src/render3/interfaces/styling.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { StyleSanitizeFn } from '../../sanitization/style_sanitizer';
-import { LElementNode } from './node';
+import { RElement } from '../interfaces/renderer';
 import { PlayerContext } from './player';
 /**
  * The styling context acts as a styling manifest (shaped as an array) for determining which
@@ -115,11 +115,7 @@ import { PlayerContext } from './player';
  */
 export interface StylingContext extends Array<InitialStyles | {
     [key: string]: any;
-} | number | string | boolean | LElementNode | StyleSanitizeFn | PlayerContext | null> {
-    /**
-     * Location of element that is used as a target for this context.
-     */
-    [StylingIndex.ElementPosition]: LElementNode | null;
+} | number | string | boolean | RElement | StyleSanitizeFn | PlayerContext | null> {
     /**
      * Location of animation context (which contains the active players) for this element styling
      * context.
@@ -145,6 +141,10 @@ export interface StylingContext extends Array<InitialStyles | {
      * need to take into account any style values that exist in the context.
      */
     [StylingIndex.ClassOffsetPosition]: number;
+    /**
+     * Location of element that is used as a target for this context.
+     */
+    [StylingIndex.ElementPosition]: RElement | null;
     /**
      * The last class value that was interpreted by elementStylingMap. This is cached
      * So that the algorithm can exit early incase the value has not changed.
@@ -180,24 +180,26 @@ export declare const enum StylingFlags {
     Dirty = 1,
     Class = 2,
     Sanitize = 4,
-    BitCountSize = 3,
-    BitMask = 7
+    PlayerBuildersDirty = 8,
+    BitCountSize = 4,
+    BitMask = 15
 }
 /** Used as numeric pointer values to determine what cells to update in the `StylingContext` */
 export declare const enum StylingIndex {
-    ElementPosition = 0,
-    PlayerContext = 1,
-    StyleSanitizerPosition = 2,
-    InitialStylesPosition = 3,
-    MasterFlagPosition = 4,
-    ClassOffsetPosition = 5,
+    PlayerContext = 0,
+    StyleSanitizerPosition = 1,
+    InitialStylesPosition = 2,
+    MasterFlagPosition = 3,
+    ClassOffsetPosition = 4,
+    ElementPosition = 5,
     PreviousMultiClassValue = 6,
     PreviousMultiStyleValue = 7,
     SingleStylesStartPosition = 8,
     FlagsOffset = 0,
     PropertyOffset = 1,
     ValueOffset = 2,
-    Size = 3,
+    PlayerBuilderIndexOffset = 3,
+    Size = 4,
     BitCountSize = 14,
     BitMask = 16383
 }