@angular/core 7.0.0-rc.1 → 7.0.3

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

@@ -9,7 +9,7 @@
  * 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 { NEXT, PARENT, QUERIES } from './view';
+import { HOST, NEXT, PARENT, QUERIES } from './view';
 /** *
  * Below are constants for LContainer indices to help us look up LContainer members
  * without having to remember the specific indices.
@@ -17,11 +17,13 @@ import { NEXT, PARENT, QUERIES } from './view';
   @type {?} */
 export const ACTIVE_INDEX = 0;
 /** @type {?} */
-export const VIEWS = 4;
+export const VIEWS = 1;
 /** @type {?} */
-export const RENDER_PARENT = 5;
+export const NATIVE = 6;
+/** @type {?} */
+export const RENDER_PARENT = 7;
 /**
- * The state associated with an LContainerNode.
+ * The state associated with a container.
  *
  * This is an array so that its structure is closer to LViewData. This helps
  * when traversing the view tree (which is a mix of containers and component
@@ -33,4 +35,4 @@ export function LContainer() { }
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ */
+/**
+ * @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
+ */
+/** *
+ * This property will be monkey-patched on elements, components and directives
+  @type {?} */
+export const MONKEY_PATCH_KEY_NAME = '__ngContext__';
+/**
+ * The internal view context which is specific to a given DOM element, directive or
+ * component instance. Each value in here (besides the LViewData and element node details)
+ * can be present, null or undefined. If undefined then it implies the value has not been
+ * looked up yet, otherwise, if null, then a lookup was executed and nothing was found.
+ *
+ * Each value will get filled when the respective value is examined within the getContext
+ * function. The component, element and each directive instance will share the same instance
+ * of the context.
+ * @record
+ */
+export function LContext() { }
+/**
+ * The component's parent view data.
+ * @type {?}
+ */
+LContext.prototype.lViewData;
+/**
+ * The index instance of the node.
+ * @type {?}
+ */
+LContext.prototype.nodeIndex;
+/**
+ * The instance of the DOM node that is attached to the lNode.
+ * @type {?}
+ */
+LContext.prototype.native;
+/**
+ * The instance of the Component node.
+ * @type {?}
+ */
+LContext.prototype.component;
+/**
+ * The list of active directives that exist on this element.
+ * @type {?}
+ */
+LContext.prototype.directives;
+/**
+ * The map of local references (local reference name => element or directive instance) that exist
+ * on this element.
+ * @type {?}
+ */
+LContext.prototype.localRefs;
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -286,6 +286,12 @@ ComponentDef.prototype.directiveDefs;
  * @type {?}
  */
 ComponentDef.prototype.pipeDefs;
+/**
+ * Used to store the result of `noSideEffects` function so that it is not removed by closure
+ * compiler. The property should never be read.
+ * @type {?|undefined}
+ */
+ComponentDef.prototype._;
 /**
  * Runtime link information for Pipes.
  *
@@ -367,4 +373,4 @@ var InitialStylingFlags = {
 };
 export { InitialStylingFlags };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;IAmCE,SAAa;;IAGb,SAAa;;;;;;;;;;;;;;;;;;;;;;;IAesB,eAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0SxD,aAAa,6BAA6B,GAAG,CAAC,CAAC;;;IAG7C,cAAiB","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 {Provider, ViewEncapsulation} from '../../core';\nimport {Type} from '../../type';\nimport {CssSelectorList} from './projection';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  (rf: RenderFlags, ctx: T): void; ngPrivateData?: never;\n};\n\n/**\n * Definition of what a query function should look like.\n */\nexport type ComponentQuery<T> = ComponentTemplate<T>;\n\n/**\n * Flags passed into template functions to determine which blocks (i.e. creation, update)\n * should be executed.\n *\n * Typically, a template runs both the creation block and the update block on initialization and\n * subsequent runs only execute the update block. However, dynamically created views require that\n * the creation block be executed separately from the update block (for backwards compat).\n */\nexport const enum RenderFlags {\n  /* Whether to run the creation block (e.g. create elements and directives) */\n  Create = 0b01,\n\n  /* Whether to run the update block (e.g. refresh bindings) */\n  Update = 0b10\n}\n\n/**\n * A subclass of `Type` which has a static `ngComponentDef`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> { ngComponentDef: never; }\n\n/**\n * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> { ngDirectiveDef: never; }\n\nexport const enum DirectiveDefFlags {ContentQuery = 0b10}\n\n/**\n * A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> { ngPipeDef: never; }\n\nexport type DirectiveDefWithMeta<\n    T, Selector extends string, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = DirectiveDef<T>;\n\n/**\n * Runtime information for classes that are inherited by components or directives\n * that aren't defined as components or directives.\n *\n * This is an internal data structure used by the render to determine what inputs\n * and outputs should be inherited.\n *\n * See: {@link defineBase}\n */\nexport interface BaseDef<T> {\n  /**\n   * A dictionary mapping the inputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Input('alias') propertyName: any;`).\n   */\n  readonly inputs: {[P in keyof T]: string};\n\n  /**\n   * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of\n   * public or minified name.\n   */\n  readonly declaredInputs: {[P in keyof T]: P};\n\n  /**\n   * A dictionary mapping the outputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Output('alias') propertyName: any;`).\n   */\n  readonly outputs: {[P in keyof T]: P};\n}\n\n/**\n * Runtime link information for Directives.\n *\n * This is internal data structure used by the render to link\n * directives into templates.\n *\n * NOTE: Always use `defineDirective` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * @param Selector type metadata specifying the selector of the directive or component\n *\n * See: {@link defineDirective}\n */\nexport interface DirectiveDef<T> extends BaseDef<T> {\n  /** Token representing the directive. Used by DI. */\n  type: Type<T>;\n\n  /** Function that makes a directive public to the DI system. */\n  diPublic: ((def: DirectiveDef<T>) => void)|null;\n\n  /** The selectors that will be used to match nodes to this directive. */\n  selectors: CssSelectorList;\n\n  /**\n   * Name under which the directive is exported (for use with local references in template)\n   */\n  readonly exportAs: string|null;\n\n  /**\n   * Factory function used to create a new directive instance.\n   */\n  factory(): T;\n\n  /**\n   * Function to create instances of content queries associated with a given directive.\n   */\n  contentQueries: (() => void)|null;\n\n  /** Refreshes content queries associated with directives in a given view */\n  contentQueriesRefresh: ((directiveIndex: number, queryIndex: number) => void)|null;\n\n  /**\n   * The number of host bindings (including pure fn bindings) in this directive/component.\n   *\n   * Used to calculate the length of the LViewData array for the *parent* component\n   * of this directive/component.\n   */\n  hostVars: number;\n\n  /** Refreshes host bindings on the associated directive. */\n  hostBindings: HostBindingsFunction|null;\n\n  /**\n   * Static attributes to set on host element.\n   *\n   * Even indices: attribute name\n   * Odd indices: attribute value\n   */\n  attributes: string[]|null;\n\n  /* The following are lifecycle hooks for this component */\n  onInit: (() => void)|null;\n  doCheck: (() => void)|null;\n  afterContentInit: (() => void)|null;\n  afterContentChecked: (() => void)|null;\n  afterViewInit: (() => void)|null;\n  afterViewChecked: (() => void)|null;\n  onDestroy: (() => void)|null;\n\n  /**\n   * The features applied to this directive\n   */\n  features: DirectiveDefFeature[]|null;\n}\n\nexport type ComponentDefWithMeta<\n    T, Selector extends String, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = ComponentDef<T>;\n\n/**\n * Runtime link information for Components.\n *\n * This is internal data structure used by the render to link\n * components into templates.\n *\n * NOTE: Always use `defineComponent` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link defineComponent}\n */\nexport interface ComponentDef<T> extends DirectiveDef<T> {\n  /**\n   * Runtime unique component ID.\n   */\n  id: string;\n\n  /**\n   * The View template of the component.\n   */\n  readonly template: ComponentTemplate<T>;\n\n  /**\n   * A set of styles that the component needs to be present for component to render correctly.\n   */\n  readonly styles: string[];\n\n  /**\n   * The number of nodes, local refs, and pipes in this component template.\n   *\n   * Used to calculate the length of the component's LViewData array, so we\n   * can pre-fill the array and set the binding start index.\n   */\n  // TODO(kara): remove queries from this count\n  consts: number;\n\n  /**\n   * The number of bindings in this component template (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LViewData array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  vars: number;\n\n  /**\n   * Query-related instructions for a component.\n   */\n  viewQuery: ComponentQuery<T>|null;\n\n  /**\n   * The view encapsulation type, which determines how styles are applied to\n   * DOM elements. One of\n   * - `Emulated` (default): Emulate native scoping of styles.\n   * - `Native`: Use the native encapsulation mechanism of the renderer.\n   * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   *   create a ShadowRoot for component's host element.\n   * - `None`: Do not provide any template or style encapsulation.\n   */\n  readonly encapsulation: ViewEncapsulation;\n\n  /**\n   * Defines arbitrary developer-defined data to be stored on a renderer instance.\n   * This is useful for renderers that delegate to other renderers.\n   */\n  readonly data: {[kind: string]: any};\n\n  /** Whether or not this component's ChangeDetectionStrategy is OnPush */\n  readonly onPush: boolean;\n\n  /**\n   * Defines the set of injectable providers that are visible to a Directive and its content DOM\n   * children.\n   */\n  readonly providers: Provider[]|null;\n\n  /**\n   * Defines the set of injectable providers that are visible to a Directive and its view DOM\n   * children only.\n   */\n  readonly viewProviders: Provider[]|null;\n\n  /**\n   * Registry of directives and components that may be found in this view.\n   *\n   * The property is either an array of `DirectiveDef`s or a function which returns the array of\n   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.\n   */\n  directiveDefs: DirectiveDefListOrFactory|null;\n\n  /**\n   * Registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   */\n  pipeDefs: PipeDefListOrFactory|null;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is internal data structure used by the renderer to link\n * pipes into templates.\n *\n * NOTE: Always use `definePipe` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link definePipe}\n */\nexport interface PipeDef<T> {\n  /**\n   * Pipe name.\n   *\n   * Used to resolve pipe in templates.\n   */\n  name: string;\n\n  /**\n   * Factory function used to create a new pipe instance.\n   */\n  factory: () => T;\n\n  /**\n   * Whether or not the pipe is pure.\n   *\n   * Pure pipes result only depends on the pipe input and not on internal\n   * state of the pipe.\n   */\n  pure: boolean;\n\n  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport type PipeDefWithMeta<T, Name extends string> = PipeDef<T>;\n\nexport type DirectiveDefFeature = <T>(directiveDef: DirectiveDef<T>) => void;\nexport type ComponentDefFeature = <T>(componentDef: ComponentDef<T>) => void;\n\n/**\n * Type used for directiveDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;\n\nexport type DirectiveDefList = (DirectiveDef<any>| ComponentDef<any>)[];\n\nexport type DirectiveTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type DirectiveTypeList =\n    (DirectiveDef<any>| ComponentDef<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type HostBindingsFunction = (directiveIndex: number, elementIndex: number) => void;\n\n/**\n * Type used for PipeDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type PipeDefListOrFactory = (() => PipeDefList) | PipeDefList;\n\nexport type PipeDefList = PipeDef<any>[];\n\nexport type PipeTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type PipeTypeList =\n    (PipeDef<any>| Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n\nexport const enum InitialStylingFlags {\n  VALUES_MODE = 0b1,\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;IAmCE,SAAa;;IAGb,SAAa;;;;;;;;;;;;;;;;;;;;;;;IAesB,eAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgTxD,aAAa,6BAA6B,GAAG,CAAC,CAAC;;;IAG7C,cAAiB","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 {Provider, ViewEncapsulation} from '../../core';\nimport {Type} from '../../type';\nimport {CssSelectorList} from './projection';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  (rf: RenderFlags, ctx: T): void; ngPrivateData?: never;\n};\n\n/**\n * Definition of what a query function should look like.\n */\nexport type ComponentQuery<T> = ComponentTemplate<T>;\n\n/**\n * Flags passed into template functions to determine which blocks (i.e. creation, update)\n * should be executed.\n *\n * Typically, a template runs both the creation block and the update block on initialization and\n * subsequent runs only execute the update block. However, dynamically created views require that\n * the creation block be executed separately from the update block (for backwards compat).\n */\nexport const enum RenderFlags {\n  /* Whether to run the creation block (e.g. create elements and directives) */\n  Create = 0b01,\n\n  /* Whether to run the update block (e.g. refresh bindings) */\n  Update = 0b10\n}\n\n/**\n * A subclass of `Type` which has a static `ngComponentDef`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> { ngComponentDef: never; }\n\n/**\n * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> { ngDirectiveDef: never; }\n\nexport const enum DirectiveDefFlags {ContentQuery = 0b10}\n\n/**\n * A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> { ngPipeDef: never; }\n\nexport type DirectiveDefWithMeta<\n    T, Selector extends string, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = DirectiveDef<T>;\n\n/**\n * Runtime information for classes that are inherited by components or directives\n * that aren't defined as components or directives.\n *\n * This is an internal data structure used by the render to determine what inputs\n * and outputs should be inherited.\n *\n * See: {@link defineBase}\n */\nexport interface BaseDef<T> {\n  /**\n   * A dictionary mapping the inputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Input('alias') propertyName: any;`).\n   */\n  readonly inputs: {[P in keyof T]: string};\n\n  /**\n   * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of\n   * public or minified name.\n   */\n  readonly declaredInputs: {[P in keyof T]: P};\n\n  /**\n   * A dictionary mapping the outputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Output('alias') propertyName: any;`).\n   */\n  readonly outputs: {[P in keyof T]: P};\n}\n\n/**\n * Runtime link information for Directives.\n *\n * This is internal data structure used by the render to link\n * directives into templates.\n *\n * NOTE: Always use `defineDirective` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * @param Selector type metadata specifying the selector of the directive or component\n *\n * See: {@link defineDirective}\n */\nexport interface DirectiveDef<T> extends BaseDef<T> {\n  /** Token representing the directive. Used by DI. */\n  type: Type<T>;\n\n  /** Function that makes a directive public to the DI system. */\n  diPublic: ((def: DirectiveDef<T>) => void)|null;\n\n  /** The selectors that will be used to match nodes to this directive. */\n  selectors: CssSelectorList;\n\n  /**\n   * Name under which the directive is exported (for use with local references in template)\n   */\n  readonly exportAs: string|null;\n\n  /**\n   * Factory function used to create a new directive instance.\n   */\n  factory(): T;\n\n  /**\n   * Function to create instances of content queries associated with a given directive.\n   */\n  contentQueries: (() => void)|null;\n\n  /** Refreshes content queries associated with directives in a given view */\n  contentQueriesRefresh: ((directiveIndex: number, queryIndex: number) => void)|null;\n\n  /**\n   * The number of host bindings (including pure fn bindings) in this directive/component.\n   *\n   * Used to calculate the length of the LViewData array for the *parent* component\n   * of this directive/component.\n   */\n  hostVars: number;\n\n  /** Refreshes host bindings on the associated directive. */\n  hostBindings: HostBindingsFunction|null;\n\n  /**\n   * Static attributes to set on host element.\n   *\n   * Even indices: attribute name\n   * Odd indices: attribute value\n   */\n  attributes: string[]|null;\n\n  /* The following are lifecycle hooks for this component */\n  onInit: (() => void)|null;\n  doCheck: (() => void)|null;\n  afterContentInit: (() => void)|null;\n  afterContentChecked: (() => void)|null;\n  afterViewInit: (() => void)|null;\n  afterViewChecked: (() => void)|null;\n  onDestroy: (() => void)|null;\n\n  /**\n   * The features applied to this directive\n   */\n  features: DirectiveDefFeature[]|null;\n}\n\nexport type ComponentDefWithMeta<\n    T, Selector extends String, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = ComponentDef<T>;\n\n/**\n * Runtime link information for Components.\n *\n * This is internal data structure used by the render to link\n * components into templates.\n *\n * NOTE: Always use `defineComponent` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link defineComponent}\n */\nexport interface ComponentDef<T> extends DirectiveDef<T> {\n  /**\n   * Runtime unique component ID.\n   */\n  readonly id: string;\n\n  /**\n   * The View template of the component.\n   */\n  readonly template: ComponentTemplate<T>;\n\n  /**\n   * A set of styles that the component needs to be present for component to render correctly.\n   */\n  readonly styles: string[];\n\n  /**\n   * The number of nodes, local refs, and pipes in this component template.\n   *\n   * Used to calculate the length of the component's LViewData array, so we\n   * can pre-fill the array and set the binding start index.\n   */\n  // TODO(kara): remove queries from this count\n  readonly consts: number;\n\n  /**\n   * The number of bindings in this component template (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LViewData array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly vars: number;\n\n  /**\n   * Query-related instructions for a component.\n   */\n  viewQuery: ComponentQuery<T>|null;\n\n  /**\n   * The view encapsulation type, which determines how styles are applied to\n   * DOM elements. One of\n   * - `Emulated` (default): Emulate native scoping of styles.\n   * - `Native`: Use the native encapsulation mechanism of the renderer.\n   * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   *   create a ShadowRoot for component's host element.\n   * - `None`: Do not provide any template or style encapsulation.\n   */\n  readonly encapsulation: ViewEncapsulation;\n\n  /**\n   * Defines arbitrary developer-defined data to be stored on a renderer instance.\n   * This is useful for renderers that delegate to other renderers.\n   */\n  readonly data: {[kind: string]: any};\n\n  /** Whether or not this component's ChangeDetectionStrategy is OnPush */\n  readonly onPush: boolean;\n\n  /**\n   * Defines the set of injectable providers that are visible to a Directive and its content DOM\n   * children.\n   */\n  readonly providers: Provider[]|null;\n\n  /**\n   * Defines the set of injectable providers that are visible to a Directive and its view DOM\n   * children only.\n   */\n  readonly viewProviders: Provider[]|null;\n\n  /**\n   * Registry of directives and components that may be found in this view.\n   *\n   * The property is either an array of `DirectiveDef`s or a function which returns the array of\n   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.\n   */\n  directiveDefs: DirectiveDefListOrFactory|null;\n\n  /**\n   * Registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   */\n  pipeDefs: PipeDefListOrFactory|null;\n\n  /**\n   * Used to store the result of `noSideEffects` function so that it is not removed by closure\n   * compiler. The property should never be read.\n   */\n  readonly _?: never;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is internal data structure used by the renderer to link\n * pipes into templates.\n *\n * NOTE: Always use `definePipe` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link definePipe}\n */\nexport interface PipeDef<T> {\n  /**\n   * Pipe name.\n   *\n   * Used to resolve pipe in templates.\n   */\n  name: string;\n\n  /**\n   * Factory function used to create a new pipe instance.\n   */\n  factory: () => T;\n\n  /**\n   * Whether or not the pipe is pure.\n   *\n   * Pure pipes result only depends on the pipe input and not on internal\n   * state of the pipe.\n   */\n  pure: boolean;\n\n  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport type PipeDefWithMeta<T, Name extends string> = PipeDef<T>;\n\nexport type DirectiveDefFeature = <T>(directiveDef: DirectiveDef<T>) => void;\nexport type ComponentDefFeature = <T>(componentDef: ComponentDef<T>) => void;\n\n/**\n * Type used for directiveDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;\n\nexport type DirectiveDefList = (DirectiveDef<any>| ComponentDef<any>)[];\n\nexport type DirectiveTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type DirectiveTypeList =\n    (DirectiveDef<any>| ComponentDef<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type HostBindingsFunction = (directiveIndex: number, elementIndex: number) => void;\n\n/**\n * Type used for PipeDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type PipeDefListOrFactory = (() => PipeDefList) | PipeDefList;\n\nexport type PipeDefList = PipeDef<any>[];\n\nexport type PipeTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type PipeTypeList =\n    (PipeDef<any>| Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n\nexport const enum InitialStylingFlags {\n  VALUES_MODE = 0b1,\n}\n"]}

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

@@ -0,0 +1,338 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ */
+/**
+ * @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
+ */
+/** @enum {number} */
+var I18nMutateOpCode = {
+    SHIFT_REF: 2,
+    SHIFT_PARENT: 17,
+    MASK_OPCODE: 3,
+    MASK_REF: 68,
+    Select: 0,
+    AppendChild: 1,
+    InsertBefore: 2,
+    Remove: 3,
+};
+export { I18nMutateOpCode };
+/** *
+ * Marks that the next string is for element.
+ *
+ * See `I18nMutateOpCodes` documentation.
+  @type {?} */
+export const ELEMENT_MARKER = {
+    marker: 'element'
+};
+/** *
+ * Marks that the next string is for comment.
+ *
+ * See `I18nMutateOpCodes` documentation.
+  @type {?} */
+export const 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`;
+ * @record
+ */
+export function I18nMutateOpCodes() { }
+/** @enum {number} */
+var I18nUpdateOpCode = {
+    SHIFT_REF: 2,
+    SHIFT_ICU: 17,
+    MASK_OPCODE: 3,
+    MASK_REF: 68,
+    Text: 0,
+    Attr: 1,
+    IcuSwitch: 2,
+    IcuUpdate: 3,
+};
+export { I18nUpdateOpCode };
+/**
+ * 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,
+ *
+ * ];
+ * ```
+ *
+ * @record
+ */
+export function I18nUpdateOpCodes() { }
+/**
+ * Store information for the i18n translation block.
+ * @record
+ */
+export function 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.
+ * @type {?}
+ */
+TI18n.prototype.vars;
+/**
+ * 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.
+ * @type {?}
+ */
+TI18n.prototype.expandoStartIndex;
+/**
+ * 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.
+ * @type {?}
+ */
+TI18n.prototype.create;
+/**
+ * A set of OpCodes which will be executed on each change detection to determine if any changes to
+ * DOM are required.
+ * @type {?}
+ */
+TI18n.prototype.update;
+/**
+ * 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, ...}`
+ * @type {?}
+ */
+TI18n.prototype.icus;
+/** @enum {number} */
+var IcuType = {
+    select: 0,
+    plural: 1,
+};
+export { IcuType };
+/**
+ * @record
+ */
+export function TIcu() { }
+/**
+ * Defines the ICU type of `select` or `plural`
+ * @type {?}
+ */
+TIcu.prototype.type;
+/**
+ * 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.
+ * @type {?}
+ */
+TIcu.prototype.vars;
+/**
+ * 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.
+ * @type {?}
+ */
+TIcu.prototype.childIcus;
+/**
+ * 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.
+ * @type {?}
+ */
+TIcu.prototype.expandoStartIndex;
+/**
+ * A list of case values which the current ICU will try to match.
+ *
+ * The last value is `other`
+ * @type {?}
+ */
+TIcu.prototype.cases;
+/**
+ * A set of OpCodes to apply in order to build up the DOM render tree for the ICU
+ * @type {?}
+ */
+TIcu.prototype.create;
+/**
+ * A set of OpCodes to apply in order to destroy the DOM render tree for the ICU.
+ * @type {?}
+ */
+TIcu.prototype.remove;
+/**
+ * A set of OpCodes to apply in order to update the DOM render tree for the ICU bindings.
+ * @type {?}
+ */
+TIcu.prototype.update;
+/**
+ * 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.
+ * @record
+ */
+export function LI18n() { }
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/i18n.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAoBE,YAAa;IAEb,gBAAiB;IAEjB,cAAkB;IAElB,YAAsC;IAGtC,SAAa;IAEb,cAAkB;IAElB,eAAmB;IAEnB,SAAa;;;;;;;;AAQf,aAAa,cAAc,GAAmB;IAC5C,MAAM,EAAE,SAAS;CAClB,CAAC;;;;;;AAQF,aAAa,cAAc,GAAmB;IAC5C,MAAM,EAAE,SAAS;CAClB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmFA,YAAa;IAEb,aAAc;IAEd,cAAkB;IAElB,YAAsC;IAGtC,OAAW;IAEX,OAAW;IAEX,YAAgB;IAEhB,YAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2HhB,SAAU;IACV,SAAU","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\n/**\n * `I18nMutateOpCode` defines OpCodes for `I18nMutateOpCodes` array.\n *\n * OpCodes contain three parts:\n *  1) Parent node index offset.\n *  2) Reference node index offset.\n *  3) The OpCode to execute.\n *\n * See: `I18nCreateOpCodes` for example of usage.\n */\nexport const enum I18nMutateOpCode {\n  /// Stores shift amount for bits 17-2 that contain reference index.\n  SHIFT_REF = 2,\n  /// Stores shift amount for bits 31-17 that contain parent index.\n  SHIFT_PARENT = 17,\n  /// Mask for OpCode\n  MASK_OPCODE = 0b11,\n  /// Mask for reference index.\n  MASK_REF = ((2 ^ 16) - 1) << SHIFT_REF,\n\n  /// OpCode to select a node. (next OpCode will contain the operation.)\n  Select = 0b00,\n  /// OpCode to append the current node to `PARENT`.\n  AppendChild = 0b01,\n  /// OpCode to insert the current node to `PARENT` before `REF`.\n  InsertBefore = 0b10,\n  /// OpCode to remove the `REF` node from `PARENT`.\n  Remove = 0b11,\n}\n\n/**\n * Marks that the next string is for element.\n *\n * See `I18nMutateOpCodes` documentation.\n */\nexport const ELEMENT_MARKER: ELEMENT_MARKER = {\n  marker: 'element'\n};\nexport interface ELEMENT_MARKER { marker: 'element'; }\n\n/**\n * Marks that the next string is for comment.\n *\n * See `I18nMutateOpCodes` documentation.\n */\nexport const COMMENT_MARKER: COMMENT_MARKER = {\n  marker: 'comment'\n};\n\nexport interface COMMENT_MARKER { marker: 'comment'; }\n\n/**\n * Array storing OpCode for dynamically creating `i18n` blocks.\n *\n * Example:\n * ```\n * <I18nCreateOpCode>[\n *   // For adding text nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createTextNode('abc');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   'abc', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createTextNode('xyz');\n *   //   lViewData[1].appendChild(node);\n *   'xyz', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For adding element nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createElement('div');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createElement('div');\n *   //   lViewData[1].appendChild(node);\n *   ELEMENT_MARKER, 'div', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For adding comment nodes\n *   // ---------------------\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createComment('');\n *   //   lViewData[1].insertBefore(node, lViewData[2]);\n *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | 2 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[index++] = document.createComment('');\n *   //   lViewData[1].appendChild(node);\n *   COMMENT_MARKER, '', 1 << SHIFT_PARENT | AppendChild,\n *\n *   // For moving existing nodes to a different location\n *   // --------------------------------------------------\n *   // Equivalent to:\n *   //   const node = lViewData[1];\n *   //   lViewData[2].insertBefore(node, lViewData[3]);\n *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | 3 << SHIFT_REF | InsertBefore,\n *\n *   // Equivalent to:\n *   //   const node = lViewData[1];\n *   //   lViewData[2].appendChild(node);\n *   1 << SHIFT_REF | Select, 2 << SHIFT_PARENT | AppendChild,\n *\n *   // For removing existing nodes\n *   // --------------------------------------------------\n *   //   const node = lViewData[1];\n *   //   lViewData[2].remove(node);\n *   2 << SHIFT_PARENT | 1 << SHIFT_REF | Remove,\n *\n *   // For writing attributes\n *   // --------------------------------------------------\n *   //   const node = lViewData[1];\n *   //   node.setAttribute('attr', 'value');\n *   1 << SHIFT_REF | Select, 'attr', 'value'\n *            // NOTE: Select followed by two string (vs select followed by OpCode)\n * ];\n * ```\n * NOTE:\n *   - `index` is initial location where the extra nodes should be stored in the EXPANDO section of\n * `LVIewData`.\n *\n * See: `applyI18nCreateOpCodes`;\n */\nexport interface I18nMutateOpCodes extends Array<number|string|ELEMENT_MARKER|COMMENT_MARKER|null> {\n}\n\nexport const enum I18nUpdateOpCode {\n  /// Stores shift amount for bits 17-2 that contain reference index.\n  SHIFT_REF = 2,\n  /// Stores shift amount for bits 31-17 that contain which ICU in i18n block are we referring to.\n  SHIFT_ICU = 17,\n  /// Mask for OpCode\n  MASK_OPCODE = 0b11,\n  /// Mask for reference index.\n  MASK_REF = ((2 ^ 16) - 1) << SHIFT_REF,\n\n  /// OpCode to update a text node.\n  Text = 0b00,\n  /// OpCode to update a attribute of a node.\n  Attr = 0b01,\n  /// OpCode to switch the current ICU case.\n  IcuSwitch = 0b10,\n  /// OpCode to update the current ICU case.\n  IcuUpdate = 0b11,\n}\n\n/**\n * Stores DOM operations which need to be applied to update DOM render tree due to changes in\n * expressions.\n *\n * The basic idea is that `i18nExp` OpCodes capture expression changes and update a change\n * mask bit. (Bit 1 for expression 1, bit 2 for expression 2 etc..., bit 32 for expression 32 and\n * higher.) The OpCodes then compare its own change mask against the expression change mask to\n * determine if the OpCodes should execute.\n *\n * These OpCodes can be used by both the i18n block as well as ICU sub-block.\n *\n * ## Example\n *\n * Assume\n * ```\n *   if (rf & RenderFlags.Update) {\n *    i18nExp(bind(ctx.exp1)); // If changed set mask bit 1\n *    i18nExp(bind(ctx.exp2)); // If changed set mask bit 2\n *    i18nExp(bind(ctx.exp3)); // If changed set mask bit 3\n *    i18nExp(bind(ctx.exp4)); // If changed set mask bit 4\n *    i18nApply(0);            // Apply all changes by executing the OpCodes.\n *  }\n * ```\n * We can assume that each call to `i18nExp` sets an internal `changeMask` bit depending on the\n * index of `i18nExp` index.\n *\n * OpCodes\n * ```\n * <I18nUpdateOpCodes>[\n *   // The following OpCodes represent: `<div i18n-title=\"pre{{exp1}}in{{exp2}}post\">`\n *   // If `changeMask & 0b11`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `7` values and start processing next OpCodes.\n *   0b11, 7,\n *   // Concatenate `newValue = 'pre'+lViewData[bindIndex-4]+'in'+lViewData[bindIndex-3]+'post';`.\n *   'pre', -4, 'in', -3, 'post',\n *   // Update attribute: `elementAttribute(1, 'title', sanitizerFn(newValue));`\n *   1 << SHIFT_REF | Attr, 'title', sanitizerFn,\n *\n *   // The following OpCodes represent: `<div i18n>Hello {{exp3}}!\">`\n *   // If `changeMask & 0b100`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `4` values and start processing next OpCodes.\n *   0b100, 4,\n *   // Concatenate `newValue = 'Hello ' + lViewData[bindIndex -2] + '!';`.\n *   'Hello ', -2, '!',\n *   // Update text: `lViewData[1].textContent = newValue;`\n *   1 << SHIFT_REF | Text,\n *\n *   // The following OpCodes represent: `<div i18n>{exp4, plural, ... }\">`\n *   // If `changeMask & 0b1000`\n *   //        has changed then execute update OpCodes.\n *   //        has NOT changed then skip `4` values and start processing next OpCodes.\n *   0b1000, 4,\n *   // Concatenate `newValue = lViewData[bindIndex -1];`.\n *   -1,\n *   // Switch ICU: `icuSwitchCase(lViewData[1], 0, newValue);`\n *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuSwitch,\n *\n *   // Note `changeMask & -1` is always true, so the IcuUpdate will always execute.\n *   -1, 1,\n *   // Update ICU: `icuUpdateCase(lViewData[1], 0);`\n *   0 << SHIFT_ICU | 1 << SHIFT_REF | IcuUpdate,\n *\n * ];\n * ```\n *\n */\nexport interface I18nUpdateOpCodes extends Array<string|number|((text: string) => string | null)> {}\n\n/**\n * Store information for the i18n translation block.\n */\nexport interface TI18n {\n  /**\n   * Number of slots to allocate in expando.\n   *\n   * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When\n   * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can\n   * write into them.\n   */\n  vars: number;\n\n  /**\n   * Index in EXPANDO where the i18n stores its DOM nodes.\n   *\n   * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the\n   * newly created DOM nodes will be inserted.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * A set of OpCodes which will create the Text Nodes and ICU anchors for the translation blocks.\n   *\n   * NOTE: The ICU anchors are filled in with ICU Update OpCode.\n   */\n  create: I18nMutateOpCodes;\n\n  /**\n   * A set of OpCodes which will be executed on each change detection to determine if any changes to\n   * DOM are required.\n   */\n  update: I18nUpdateOpCodes;\n\n  /**\n   * A list of ICUs in a translation block (or `null` if block has no ICUs).\n   *\n   * Example:\n   * Given: `<div i18n>You have {count, plural, ...} and {state, switch, ...}</div>`\n   * There would be 2 ICUs in this array.\n   *   1. `{count, plural, ...}`\n   *   2. `{state, switch, ...}`\n   */\n  icus: TIcu[]|null;\n}\n\n/**\n * Defines the ICU type of `select` or `plural`\n */\nexport const enum IcuType {\n  select = 0,\n  plural = 1,\n}\n\nexport interface TIcu {\n  /**\n   * Defines the ICU type of `select` or `plural`\n   */\n  type: IcuType;\n\n  /**\n   * Number of slots to allocate in expando for each case.\n   *\n   * This is the max number of DOM elements which will be created by this i18n + ICU blocks. When\n   * the DOM elements are being created they are stored in the EXPANDO, so that update OpCodes can\n   * write into them.\n   */\n  vars: number[];\n\n  /**\n   * An optional array of child/sub ICUs.\n   *\n   * In case of nested ICUs such as:\n   * ```\n   * {�0�, plural,\n   *   =0 {zero}\n   *   other {�0� {�1�, select,\n   *                     cat {cats}\n   *                     dog {dogs}\n   *                     other {animals}\n   *                   }!\n   *   }\n   * }\n   * ```\n   * When the parent ICU is changing it must clean up child ICUs as well. For this reason it needs\n   * to know which child ICUs to run clean up for as well.\n   *\n   * In the above example this would be:\n   * ```\n   * [\n   *   [],   // `=0` has no sub ICUs\n   *   [1],  // `other` has one subICU at `1`st index.\n   * ]\n   * ```\n   *\n   * The reason why it is Array of Arrays is because first array represents the case, and second\n   * represents the child ICUs to clean up. There may be more than one child ICUs per case.\n   */\n  childIcus: number[][];\n\n  /**\n   * Index in EXPANDO where the i18n stores its DOM nodes.\n   *\n   * When the bindings are processed by the `i18nEnd` instruction it is necessary to know where the\n   * newly created DOM nodes will be inserted.\n   */\n  expandoStartIndex: number;\n\n  /**\n   * A list of case values which the current ICU will try to match.\n   *\n   * The last value is `other`\n   */\n  cases: any[];\n\n  /**\n   * A set of OpCodes to apply in order to build up the DOM render tree for the ICU\n   */\n  create: I18nMutateOpCodes[];\n\n  /**\n   * A set of OpCodes to apply in order to destroy the DOM render tree for the ICU.\n   */\n  remove: I18nMutateOpCodes[];\n\n  /**\n   * A set of OpCodes to apply in order to update the DOM render tree for the ICU bindings.\n   */\n  update: I18nUpdateOpCodes[];\n}\n\n/**\n * Stores currently selected case in each ICU.\n *\n * For each ICU in translation, the `Li18n` stores the currently selected case for the current\n * `LView`. For perf reasons this array is only created if a translation block has an ICU.\n */\nexport interface LI18n extends Array<number> {}\n"]}