@angular/core 7.2.0-rc.0 → 7.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "7.2.0-rc.0",
+  "version": "7.2.3",
   "description": "Angular - the core framework",
   "main": "./bundles/core.umd.js",
   "module": "./fesm5/core.js",

package/src/change_detection/constants.d.ts

@@ -15,7 +15,7 @@ export declare enum ChangeDetectionStrategy {
     /**
      * Use the `CheckOnce` strategy, meaning that automatic change detection is deactivated
      * until reactivated by setting the strategy to `Default` (`CheckAlways`).
-     * Change detection can still be explictly invoked.
+     * Change detection can still be explicitly invoked.
      */
     OnPush = 0,
     /**
@@ -40,7 +40,7 @@ export declare enum ChangeDetectorStatus {
      */
     Checked = 1,
     /**
-     * A state in which change detection continues automatically until explictly
+     * A state in which change detection continues automatically until explicitly
      * deactivated.
      */
     CheckAlways = 2,

package/src/core_render3_private_export.d.ts

@@ -5,7 +5,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
  */
-export { defineBase as ɵdefineBase, defineComponent as ɵdefineComponent, defineDirective as ɵdefineDirective, definePipe as ɵdefinePipe, defineNgModule as ɵdefineNgModule, detectChanges as ɵdetectChanges, renderComponent as ɵrenderComponent, AttributeMarker as ɵAttributeMarker, ComponentType as ɵComponentType, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, DirectiveType as ɵDirectiveType, RenderFlags as ɵRenderFlags, directiveInject as ɵdirectiveInject, injectAttribute as ɵinjectAttribute, getFactoryOf as ɵgetFactoryOf, getInheritedFactory as ɵgetInheritedFactory, templateRefExtractor as ɵtemplateRefExtractor, ProvidersFeature as ɵProvidersFeature, InheritDefinitionFeature as ɵInheritDefinitionFeature, NgOnChangesFeature as ɵNgOnChangesFeature, LifecycleHooksFeature as ɵLifecycleHooksFeature, NgModuleType as ɵNgModuleType, NgModuleRef as ɵRender3NgModuleRef, CssSelectorList as ɵCssSelectorList, markDirty as ɵmarkDirty, NgModuleFactory as ɵNgModuleFactory, NO_CHANGE as ɵNO_CHANGE, container as ɵcontainer, nextContext as ɵnextContext, elementStart as ɵelementStart, namespaceHTML as ɵnamespaceHTML, namespaceMathML as ɵnamespaceMathML, namespaceSVG as ɵnamespaceSVG, element as ɵelement, listener as ɵlistener, text as ɵtext, embeddedViewStart as ɵembeddedViewStart, query as ɵquery, registerContentQuery as ɵregisterContentQuery, projection as ɵprojection, bind as ɵbind, interpolation1 as ɵinterpolation1, interpolation2 as ɵinterpolation2, interpolation3 as ɵinterpolation3, interpolation4 as ɵinterpolation4, interpolation5 as ɵinterpolation5, interpolation6 as ɵinterpolation6, interpolation7 as ɵinterpolation7, interpolation8 as ɵinterpolation8, interpolationV as ɵinterpolationV, pipeBind1 as ɵpipeBind1, pipeBind2 as ɵpipeBind2, pipeBind3 as ɵpipeBind3, pipeBind4 as ɵpipeBind4, pipeBindV as ɵpipeBindV, pureFunction0 as ɵpureFunction0, pureFunction1 as ɵpureFunction1, pureFunction2 as ɵpureFunction2, pureFunction3 as ɵpureFunction3, pureFunction4 as ɵpureFunction4, pureFunction5 as ɵpureFunction5, pureFunction6 as ɵpureFunction6, pureFunction7 as ɵpureFunction7, pureFunction8 as ɵpureFunction8, pureFunctionV as ɵpureFunctionV, getCurrentView as ɵgetCurrentView, getHostElement as ɵgetHostElement, restoreView as ɵrestoreView, containerRefreshStart as ɵcontainerRefreshStart, containerRefreshEnd as ɵcontainerRefreshEnd, queryRefresh as ɵqueryRefresh, loadQueryList as ɵloadQueryList, elementEnd as ɵelementEnd, elementProperty as ɵelementProperty, projectionDef as ɵprojectionDef, reference as ɵreference, enableBindings as ɵenableBindings, disableBindings as ɵdisableBindings, allocHostVars as ɵallocHostVars, elementAttribute as ɵelementAttribute, elementContainerStart as ɵelementContainerStart, elementContainerEnd as ɵelementContainerEnd, elementStyling as ɵelementStyling, elementStylingMap as ɵelementStylingMap, elementStyleProp as ɵelementStyleProp, elementStylingApply as ɵelementStylingApply, elementClassProp as ɵelementClassProp, textBinding as ɵtextBinding, template as ɵtemplate, embeddedViewEnd as ɵembeddedViewEnd, store as ɵstore, load as ɵload, pipe as ɵpipe, BaseDef as ɵBaseDef, ComponentDef as ɵComponentDef, ComponentDefWithMeta as ɵComponentDefWithMeta, DirectiveDef as ɵDirectiveDef, DirectiveDefWithMeta as ɵDirectiveDefWithMeta, PipeDef as ɵPipeDef, PipeDefWithMeta as ɵPipeDefWithMeta, whenRendered as ɵwhenRendered, i18n as ɵi18n, i18nAttributes as ɵi18nAttributes, i18nExp as ɵi18nExp, i18nStart as ɵi18nStart, i18nEnd as ɵi18nEnd, i18nApply as ɵi18nApply, i18nPostprocess as ɵi18nPostprocess, setClassMetadata as ɵsetClassMetadata, } from './render3/index';
+export { defineBase as ɵdefineBase, defineComponent as ɵdefineComponent, defineDirective as ɵdefineDirective, definePipe as ɵdefinePipe, defineNgModule as ɵdefineNgModule, detectChanges as ɵdetectChanges, renderComponent as ɵrenderComponent, AttributeMarker as ɵAttributeMarker, ComponentType as ɵComponentType, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, DirectiveType as ɵDirectiveType, RenderFlags as ɵRenderFlags, directiveInject as ɵdirectiveInject, injectAttribute as ɵinjectAttribute, getFactoryOf as ɵgetFactoryOf, getInheritedFactory as ɵgetInheritedFactory, templateRefExtractor as ɵtemplateRefExtractor, ProvidersFeature as ɵProvidersFeature, InheritDefinitionFeature as ɵInheritDefinitionFeature, NgOnChangesFeature as ɵNgOnChangesFeature, LifecycleHooksFeature as ɵLifecycleHooksFeature, NgModuleType as ɵNgModuleType, NgModuleRef as ɵRender3NgModuleRef, CssSelectorList as ɵCssSelectorList, markDirty as ɵmarkDirty, NgModuleFactory as ɵNgModuleFactory, NO_CHANGE as ɵNO_CHANGE, container as ɵcontainer, nextContext as ɵnextContext, elementStart as ɵelementStart, namespaceHTML as ɵnamespaceHTML, namespaceMathML as ɵnamespaceMathML, namespaceSVG as ɵnamespaceSVG, element as ɵelement, listener as ɵlistener, text as ɵtext, embeddedViewStart as ɵembeddedViewStart, query as ɵquery, registerContentQuery as ɵregisterContentQuery, projection as ɵprojection, bind as ɵbind, interpolation1 as ɵinterpolation1, interpolation2 as ɵinterpolation2, interpolation3 as ɵinterpolation3, interpolation4 as ɵinterpolation4, interpolation5 as ɵinterpolation5, interpolation6 as ɵinterpolation6, interpolation7 as ɵinterpolation7, interpolation8 as ɵinterpolation8, interpolationV as ɵinterpolationV, pipeBind1 as ɵpipeBind1, pipeBind2 as ɵpipeBind2, pipeBind3 as ɵpipeBind3, pipeBind4 as ɵpipeBind4, pipeBindV as ɵpipeBindV, pureFunction0 as ɵpureFunction0, pureFunction1 as ɵpureFunction1, pureFunction2 as ɵpureFunction2, pureFunction3 as ɵpureFunction3, pureFunction4 as ɵpureFunction4, pureFunction5 as ɵpureFunction5, pureFunction6 as ɵpureFunction6, pureFunction7 as ɵpureFunction7, pureFunction8 as ɵpureFunction8, pureFunctionV as ɵpureFunctionV, getCurrentView as ɵgetCurrentView, getHostElement as ɵgetHostElement, restoreView as ɵrestoreView, containerRefreshStart as ɵcontainerRefreshStart, containerRefreshEnd as ɵcontainerRefreshEnd, queryRefresh as ɵqueryRefresh, loadQueryList as ɵloadQueryList, elementEnd as ɵelementEnd, elementProperty as ɵelementProperty, componentHostSyntheticProperty as ɵcomponentHostSyntheticProperty, projectionDef as ɵprojectionDef, reference as ɵreference, enableBindings as ɵenableBindings, disableBindings as ɵdisableBindings, allocHostVars as ɵallocHostVars, elementAttribute as ɵelementAttribute, elementContainerStart as ɵelementContainerStart, elementContainerEnd as ɵelementContainerEnd, elementStyling as ɵelementStyling, elementHostAttrs as ɵelementHostAttrs, elementStylingMap as ɵelementStylingMap, elementStyleProp as ɵelementStyleProp, elementStylingApply as ɵelementStylingApply, elementClassProp as ɵelementClassProp, textBinding as ɵtextBinding, template as ɵtemplate, embeddedViewEnd as ɵembeddedViewEnd, store as ɵstore, load as ɵload, pipe as ɵpipe, BaseDef as ɵBaseDef, ComponentDef as ɵComponentDef, ComponentDefWithMeta as ɵComponentDefWithMeta, DirectiveDef as ɵDirectiveDef, DirectiveDefWithMeta as ɵDirectiveDefWithMeta, PipeDef as ɵPipeDef, PipeDefWithMeta as ɵPipeDefWithMeta, whenRendered as ɵwhenRendered, i18n as ɵi18n, i18nAttributes as ɵi18nAttributes, i18nExp as ɵi18nExp, i18nStart as ɵi18nStart, i18nEnd as ɵi18nEnd, i18nApply as ɵi18nApply, i18nPostprocess as ɵi18nPostprocess, setClassMetadata as ɵsetClassMetadata, } from './render3/index';
 export { compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, } from './render3/jit/directive';
 export { compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, patchComponentDefWithScope as ɵpatchComponentDefWithScope, resetCompiledComponents as ɵresetCompiledComponents, } from './render3/jit/module';
 export { compilePipe as ɵcompilePipe, } from './render3/jit/pipe';

package/src/di/injection_token.d.ts

@@ -11,7 +11,7 @@ import { Type } from '../type';
  *
  * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
  * runtime representation) such as when injecting an interface, callable type, array or
- * parametrized type.
+ * parameterized type.
  *
  * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
  * the `Injector`. This provides additional level of type safety.

package/src/event_emitter.d.ts

@@ -5,7 +5,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 { Subject } from 'rxjs';
+import { Subject, Subscription } from 'rxjs';
 /**
  * Use in directives and components to emit custom events synchronously
  * or asynchronously, and register handlers for those events by subscribing
@@ -85,5 +85,5 @@ export declare class EventEmitter<T> extends Subject<T> {
      * @param complete When supplied, a custom handler for a completion
      * notification from this emitter.
      */
-    subscribe(generatorOrNext?: any, error?: any, complete?: any): any;
+    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
 }

package/src/linker/template_ref.d.ts

@@ -40,9 +40,11 @@ export declare abstract class TemplateRef<C> {
      */
     abstract readonly elementRef: ElementRef;
     /**
-     * Creates a view object and attaches it to the view container of the parent view.
-     * @param context The context for the new view, inherited from the anchor element.
-     * @returns The new view object.
+     * Instantiates an embedded view based on this template,
+     * and attaches it to the view container.
+     * @param context The data-binding context of the embedded view, as declared
+     * in the `<ng-template>` usage.
+     * @returns The new embedded view object.
      */
     abstract createEmbeddedView(context: C): EmbeddedViewRef<C>;
 }

package/src/metadata/di.d.ts

@@ -234,8 +234,6 @@ export interface ContentChildDecorator {
 /**
  * Type of the ContentChild metadata.
  *
- * @see `ContentChild`.
- *
  * @publicApi
  */
 export declare type ContentChild = Query;
@@ -325,7 +323,7 @@ export interface ViewChildDecorator {
      *
      * Supported selectors include:
      *   * any class with the `@Component` or `@Directive` decorator
-     *   * a template reference variable as a string (e.g. query `<my-component #cmp></my-component>
+     *   * a template reference variable as a string (e.g. query `<my-component #cmp></my-component>`
      * with `@ViewChild('cmp')`)
      *   * any provider defined in the child component tree of the current component (e.g.
      * `@ViewChild(SomeService) someService: SomeService`)

package/src/metadata/directives.d.ts

@@ -461,8 +461,8 @@ export interface Component extends Directive {
      */
     moduleId?: string;
     /**
-     * The URL of a template file for an Angular component. If provided,
-     * do not supply an inline template using `template`.
+     * The relative path or absolute URL of a template file for an Angular component.
+     * If provided, do not supply an inline template using `template`.
      *
      */
     templateUrl?: string;
@@ -473,7 +473,7 @@ export interface Component extends Directive {
      */
     template?: string;
     /**
-     * One or more URLs for files containing CSS stylesheets to use
+     * One or more relative paths or absolute URLs for files containing CSS stylesheets to use
      * in this component.
      */
     styleUrls?: string[];

package/src/render3/definition.d.ts

@@ -11,9 +11,7 @@ import { NgModuleDef } from '../metadata/ng_module';
 import { ViewEncapsulation } from '../metadata/view';
 import { Type } from '../type';
 import { BaseDef, ComponentDef, ComponentDefFeature, ComponentQuery, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFeature, DirectiveType, DirectiveTypesOrFactory, HostBindingsFunction, PipeDef, PipeType, PipeTypesOrFactory } from './interfaces/definition';
-import { CssSelectorList, SelectorFlags } from './interfaces/projection';
-export declare const EMPTY: {};
-export declare const EMPTY_ARRAY: any[];
+import { CssSelectorList } from './interfaces/projection';
 /**
  * Create a component definition object.
  *
@@ -316,7 +314,7 @@ export declare const defineDirective: <T>(directiveDefinition: {
      */
     type: Type<T>;
     /** The selectors that will be used to match nodes to this directive. */
-    selectors: (string | SelectorFlags)[][];
+    selectors: (string | import("@angular/core/src/render3/interfaces/projection").SelectorFlags)[][];
     /**
      * Factory method used to create an instance of directive.
      */

package/src/render3/di.d.ts

@@ -90,7 +90,7 @@ export declare function injectAttributeImpl(tNode: TNode, attrNameToInject: stri
  * @param notFoundValue The value to return when the injection flags is `InjectFlags.Optional`
  * @returns the value from the injector, `null` when not found, or `notFoundValue` if provided
  */
-export declare function getOrCreateInjectable<T>(tNode: TElementNode | TContainerNode | TElementContainerNode, lView: LView, token: Type<T> | InjectionToken<T>, flags?: InjectFlags, notFoundValue?: any): T | null;
+export declare function getOrCreateInjectable<T>(tNode: TElementNode | TContainerNode | TElementContainerNode | null, lView: LView, token: Type<T> | InjectionToken<T>, flags?: InjectFlags, notFoundValue?: any): T | null;
 /**
  * Searches for the given token among the node's directives and providers.
  *
@@ -98,9 +98,10 @@ export declare function getOrCreateInjectable<T>(tNode: TElementNode | TContaine
  * @param lView The view we are currently processing
  * @param token Provider token or type of a directive to look for.
  * @param canAccessViewProviders Whether view providers should be considered.
+ * @param isHostSpecialCase Whether the host special case applies.
  * @returns Index of a found directive or provider, or null when none found.
  */
-export declare function locateDirectiveOrProvider<T>(tNode: TNode, lView: LView, token: Type<T> | InjectionToken<T>, canAccessViewProviders: boolean): number | null;
+export declare function locateDirectiveOrProvider<T>(tNode: TNode, lView: LView, token: Type<T> | InjectionToken<T>, canAccessViewProviders: boolean, isHostSpecialCase: boolean | number): number | null;
 /**
 * Retrieve or instantiate the injectable from the `lData` at particular `index`.
 *
@@ -126,7 +127,7 @@ export declare function injectInjector(): NodeInjector;
 export declare class NodeInjector implements Injector {
     private _tNode;
     private _lView;
-    constructor(_tNode: TElementNode | TContainerNode | TElementContainerNode, _lView: LView);
+    constructor(_tNode: TElementNode | TContainerNode | TElementContainerNode | null, _lView: LView);
     get(token: any, notFoundValue?: any): any;
 }
 export declare function getFactoryOf<T>(type: Type<any>): ((type: Type<T> | null) => T) | null;

package/src/render3/empty.d.ts

@@ -0,0 +1,16 @@
+/**
+* @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 './ng_dev_mode';
+/**
+ * This file contains reuseable "empty" symbols that can be used as default return values
+ * in different parts of the rendering code. Because the same symbols are returned, this
+ * allows for identity checks against these values to be consistently used by the framework
+ * code.
+ */
+export declare const EMPTY_OBJ: {};
+export declare const EMPTY_ARRAY: any[];

package/src/render3/hooks.d.ts

@@ -30,16 +30,16 @@ export declare function queueLifecycleHooks(tView: TView, tNode: TNode): void;
  *
  * @param currentView The current view
  */
-export declare function executeInitHooks(currentView: LView, tView: TView, creationMode: boolean): void;
+export declare function executeInitHooks(currentView: LView, tView: TView, checkNoChangesMode: boolean): void;
 /**
  * Iterates over afterViewInit and afterViewChecked functions and calls them.
  *
  * @param currentView The current view
  */
-export declare function executeHooks(data: LView, allHooks: HookData | null, checkHooks: HookData | null, creationMode: boolean): void;
+export declare function executeHooks(currentView: LView, allHooks: HookData | null, checkHooks: HookData | null, checkNoChangesMode: boolean): void;
 /**
  * Calls lifecycle hooks with their contexts, skipping init hooks if it's not
- * creation mode.
+ * the first LView pass.
  *
  * @param currentView The current view
  * @param arr The array in which the hooks are found

package/src/render3/index.d.ts

@@ -16,7 +16,7 @@ export { ComponentFactory, ComponentFactoryResolver, ComponentRef, injectCompone
 export { getFactoryOf, getInheritedFactory } from './di';
 export { RenderFlags } from './interfaces/definition';
 export { CssSelectorList } from './interfaces/projection';
-export { allocHostVars, bind, interpolation1, interpolation2, interpolation3, interpolation4, interpolation5, interpolation6, interpolation7, interpolation8, interpolationV, container, containerRefreshStart, containerRefreshEnd, nextContext, element, elementAttribute, elementClassProp, elementEnd, elementProperty, elementStart, elementContainerStart, elementContainerEnd, elementStyling, elementStylingMap, elementStyleProp, elementStylingApply, listener, store, load, namespaceHTML, namespaceMathML, namespaceSVG, projection, projectionDef, text, textBinding, template, reference, embeddedViewStart, embeddedViewEnd, detectChanges, markDirty, tick, directiveInject, injectAttribute, getCurrentView } from './instructions';
+export { allocHostVars, bind, interpolation1, interpolation2, interpolation3, interpolation4, interpolation5, interpolation6, interpolation7, interpolation8, interpolationV, container, containerRefreshStart, containerRefreshEnd, nextContext, element, elementAttribute, elementClassProp, elementEnd, elementProperty, componentHostSyntheticProperty, elementStart, elementContainerStart, elementContainerEnd, elementStyling, elementHostAttrs, elementStylingMap, elementStyleProp, elementStylingApply, listener, store, load, namespaceHTML, namespaceMathML, namespaceSVG, projection, projectionDef, text, textBinding, template, reference, embeddedViewStart, embeddedViewEnd, detectChanges, markDirty, tick, directiveInject, injectAttribute, getCurrentView } from './instructions';
 export { restoreView, enableBindings, disableBindings, } from './state';
 export { i18n, i18nAttributes, i18nExp, i18nStart, i18nEnd, i18nApply, i18nPostprocess } from './i18n';
 export { NgModuleFactory, NgModuleRef, NgModuleType } from './ng_module_ref';

package/src/render3/instructions.d.ts

@@ -13,7 +13,7 @@ import { Sanitizer } from '../sanitization/security';
 import { StyleSanitizeFn } from '../sanitization/style_sanitizer';
 import { Type } from '../type';
 import { LContainer } from './interfaces/container';
-import { ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDefListOrFactory, InitialStylingFlags, PipeDefListOrFactory, RenderFlags } from './interfaces/definition';
+import { ComponentDef, ComponentQuery, ComponentTemplate, DirectiveDefListOrFactory, PipeDefListOrFactory, RenderFlags } from './interfaces/definition';
 import { LocalRefExtractor, TAttributes, TContainerNode, TElementContainerNode, TElementNode, TNode, TNodeType, TProjectionNode, TViewNode } from './interfaces/node';
 import { PlayerFactory } from './interfaces/player';
 import { CssSelectorList } from './interfaces/projection';
@@ -28,7 +28,7 @@ import { NO_CHANGE } from './tokens';
  * bindings, refreshes child components.
  * Note: view hooks are triggered later when leaving the view.
  */
-export declare function refreshDescendantViews(lView: LView, rf: RenderFlags | null): void;
+export declare function refreshDescendantViews(lView: LView): void;
 /** Sets the host bindings for the current view. */
 export declare function setHostBindings(tView: TView, viewData: LView): void;
 export declare function createLView<T>(parentLView: LView | null, tView: TView, context: T | null, flags: LViewFlags, rendererFactory?: RendererFactory3 | null, renderer?: Renderer3 | null, sanitizer?: Sanitizer | null, injector?: Injector | null): LView;
@@ -82,7 +82,7 @@ export declare function createEmbeddedViewAndNode<T>(tView: TView, context: T, d
  * can't store TViews in the template function itself (as we do for comps). Instead, we store the
  * TView for dynamically created views on their host TNode, which only has one instance.
  */
-export declare function renderEmbeddedTemplate<T>(viewToRender: LView, tView: TView, context: T, rf: RenderFlags): void;
+export declare function renderEmbeddedTemplate<T>(viewToRender: LView, tView: TView, context: T): void;
 /**
  * Retrieves a context at the level specified and saves it as the global, contextViewData.
  * Will get the next level up if level is not specified.
@@ -102,7 +102,8 @@ export declare function namespaceHTML(): void;
  *
  * @param index Index of the element in the data array
  * @param name Name of the DOM Node
- * @param attrs Statically bound set of attributes to be written into the DOM element on creation.
+ * @param attrs Statically bound set of attributes, classes, and styles to be written into the DOM
+ *              element on creation. Use [AttributeMarker] to denote the meaning of this array.
  * @param localRefs A set of local reference bindings on the element.
  */
 export declare function element(index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
@@ -126,7 +127,8 @@ export declare function elementContainerEnd(): void;
  *
  * @param index Index of the element in the LView array
  * @param name Name of the DOM Node
- * @param attrs Statically bound set of attributes to be written into the DOM element on creation.
+ * @param attrs Statically bound set of attributes, classes, and styles to be written into the DOM
+ *              element on creation. Use [AttributeMarker] to denote the meaning of this array.
  * @param localRefs A set of local reference bindings on the element.
  *
  * Attributes and localRefs are passed as an array of strings where elements with an even index
@@ -226,6 +228,28 @@ export declare function elementAttribute(index: number, name: string, value: any
  * (this is necessary for host property bindings)
  */
 export declare function elementProperty<T>(index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
+/**
+ * Updates a synthetic host binding (e.g. `[@foo]`) on a component.
+ *
+ * This instruction is for compatibility purposes and is designed to ensure that a
+ * synthetic host binding (e.g. `@HostBinding('@foo')`) properly gets rendered in
+ * the component's renderer. Normally all host bindings are evaluated with the parent
+ * component's renderer, but, in the case of animation @triggers, they need to be
+ * evaluated with the sub components renderer (because that's where the animation
+ * triggers are defined).
+ *
+ * Do not use this instruction as a replacement for `elementProperty`. This instruction
+ * only exists to ensure compatibility with the ViewEngine's host binding behavior.
+ *
+ * @param index The index of the element to update in the data array
+ * @param propName Name of property. Because it is going to DOM, this is not subject to
+ *        renaming as part of minification.
+ * @param value New value to write.
+ * @param sanitizer An optional function used to sanitize the value.
+ * @param nativeOnly Whether or not we should only set native properties and skip input check
+ * (this is necessary for host property bindings)
+ */
+export declare function componentHostSyntheticProperty<T>(index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
 /**
  * Constructs a TNode object from the arguments.
  *
@@ -238,106 +262,128 @@ export declare function elementProperty<T>(index: number, propName: string, valu
  */
 export declare function createTNode(lView: LView, type: TNodeType, adjustedIndex: number, tagName: string | null, attrs: TAttributes | null, tViews: TView[] | null): TNode;
 /**
- * Add or remove a class in a `classList` on a DOM element.
+ * Assign any inline style values to the element during creation mode.
  *
- * This instruction is meant to handle the [class.foo]="exp" case
+ * This instruction is meant to be called during creation mode to register all
+ * dynamic style and class bindings on the element. Note for static values (no binding)
+ * see `elementStart` and `elementHostAttrs`.
+ *
+ * @param classBindingNames An array containing bindable class names.
+ *        The `elementClassProp` refers to the class name by index in this array.
+ *        (i.e. `['foo', 'bar']` means `foo=0` and `bar=1`).
+ * @param styleBindingNames An array containing bindable style properties.
+ *        The `elementStyleProp` refers to the class name by index in this array.
+ *        (i.e. `['width', 'height']` means `width=0` and `height=1`).
+ * @param styleSanitizer An optional sanitizer function that will be used to sanitize any CSS
+ *        property values that are applied to the element (during rendering).
+ *        Note that the sanitizer instance itself is tied to the `directive` (if  provided).
+ * @param directive A directive instance the styling is associated with. If not provided
+ *        current view's controller instance is assumed.
  *
- * @param index The index of the element to update in the data array
- * @param classIndex Index of class to toggle. Because it is going to DOM, this is not subject to
- *        renaming as part of minification.
- * @param value A value indicating if a given class should be added or removed.
- * @param directive the ref to the directive that is attempting to change styling.
+ * @publicApi
  */
-export declare function elementClassProp(index: number, classIndex: number, value: boolean | PlayerFactory, directive?: {}): void;
+export declare function elementStyling(classBindingNames?: string[] | null, styleBindingNames?: string[] | null, styleSanitizer?: StyleSanitizeFn | null, directive?: {}): void;
 /**
- * Assign any inline style values to the element during creation mode.
+ * Assign static styling values to a host element.
  *
- * This instruction is meant to be called during creation mode to apply all styling
- * (e.g. `style="..."`) values to the element. This is also where the provided index
- * value is allocated for the styling details for its corresponding element (the element
- * index is the previous index value from this one).
+ * NOTE: This instruction is meant to used from `hostBindings` function only.
  *
- * (Note this function calls `elementStylingApply` immediately when called.)
+ * @param directive A directive instance the styling is associated with.
+ * @param attrs An array containing class and styling information. The values must be marked with
+ *              `AttributeMarker`.
  *
+ *        ```
+ *        var attrs = [AttributeMarker.Classes, 'foo', 'bar',
+ *                     AttributeMarker.Styles, 'width', '100px', 'height, '200px']
+ *        elementHostAttrs(directive, attrs);
+ *        ```
  *
- * @param index Index value which will be allocated to store styling data for the element.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
- * @param classDeclarations A key/value array of CSS classes that will be registered on the element.
- *   Each individual style will be used on the element as long as it is not overridden
- *   by any classes placed on the element by multiple (`[class]`) or singular (`[class.named]`)
- *   bindings. If a class binding changes its value to a falsy value then the matching initial
- *   class value that are passed in here will be applied to the element (if matched).
- * @param styleDeclarations A key/value array of CSS styles that will be registered on the element.
- *   Each individual style will be used on the element as long as it is not overridden
- *   by any styles placed on the element by multiple (`[style]`) or singular (`[style.prop]`)
- *   bindings. If a style binding changes its value to null then the initial styling
- *   values that are passed in here will be applied to the element (if matched).
- * @param styleSanitizer An optional sanitizer function that will be used (if provided)
- *   to sanitize the any CSS property values that are applied to the element (during rendering).
- * @param directive the ref to the directive that is attempting to change styling.
+ * @publicApi
  */
-export declare function elementStyling(classDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleDeclarations?: (string | boolean | InitialStylingFlags)[] | null, styleSanitizer?: StyleSanitizeFn | null, directive?: {}): void;
+export declare function elementHostAttrs(directive: any, attrs: TAttributes): void;
 /**
- * Apply all styling values to the element which have been queued by any styling instructions.
+ * Apply styling binding to the element.
  *
- * This instruction is meant to be run once one or more `elementStyle` and/or `elementStyleProp`
- * have been issued against the element. This function will also determine if any styles have
- * changed and will then skip the operation if there is nothing new to render.
+ * This instruction is meant to be run after `elementStyle` and/or `elementStyleProp`.
+ * if any styling bindings have changed then the changes are flushed to the element.
  *
- * Once called then all queued styles will be flushed.
  *
- * @param index Index of the element's styling storage that will be rendered.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
- * @param directive the ref to the directive that is attempting to change styling.
+ * @param index Index of the element's with which styling is associated.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+components
+ *
+ * @publicApi
  */
-export declare function elementStylingApply(index: number, directive?: {}): void;
+export declare function elementStylingApply(index: number, directive?: any): void;
 /**
- * Queue a given style to be rendered on an Element.
+ * Update a style bindings value on an element.
  *
  * If the style value is `null` then it will be removed from the element
  * (or assigned a different value depending if there are any styles placed
  * on the element with `elementStyle` or any styles that are present
  * from when the element was created (with `elementStyling`).
  *
- * (Note that the styling instruction will not be applied until `elementStylingApply` is called.)
+ * (Note that the styling element is updated as part of `elementStylingApply`.)
  *
- * @param index Index of the element's styling storage to change in the data array.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
- * @param styleIndex Index of the style property on this element. (Monotonically increasing.)
- * @param value New value to write (null to remove).
+ * @param index Index of the element's with which styling is associated.
+ * @param styleIndex Index of style to update. This index value refers to the
+ *        index of the style in the style bindings array that was passed into
+ *        `elementStlyingBindings`.
+ * @param value New value to write (null to remove). Note that if a directive also
+ *        attempts to write to the same binding value then it will only be able to
+ *        do so if the template binding value is `null` (or doesn't exist at all).
  * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.
  *        Note that when a suffix is provided then the underlying sanitizer will
  *        be ignored.
- * @param directive the ref to the directive that is attempting to change styling.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+components
+ *
+ * @publicApi
+ */
+export declare function elementStyleProp(index: number, styleIndex: number, value: string | number | String | PlayerFactory | null, suffix?: string | null, directive?: {}): void;
+/**
+ * Add or remove a class via a class binding on a DOM element.
+ *
+ * This instruction is meant to handle the [class.foo]="exp" case and, therefore,
+ * the class itself must already be applied using `elementStyling` within
+ * the creation block.
+ *
+ * @param index Index of the element's with which styling is associated.
+ * @param classIndex Index of class to toggle. This index value refers to the
+ *        index of the class in the class bindings array that was passed into
+ *        `elementStlyingBindings` (which is meant to be called before this
+ *        function is).
+ * @param value A true/false value which will turn the class on or off.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+components
+ *
+ * @publicApi
  */
-export declare function elementStyleProp(index: number, styleIndex: number, value: string | number | String | PlayerFactory | null, suffix?: string, directive?: {}): void;
+export declare function elementClassProp(index: number, classIndex: number, value: boolean | PlayerFactory, directive?: {}): void;
 /**
- * Queue a key/value map of styles to be rendered on an Element.
+ * Update style and/or class bindings using object literal.
  *
- * This instruction is meant to handle the `[style]="exp"` usage. When styles are applied to
- * the Element they will then be placed with respect to any styles set with `elementStyleProp`.
- * If any styles are set to `null` then they will be removed from the element (unless the same
- * style properties have been assigned to the element during creation using `elementStyling`).
+ * This instruction is meant apply styling via the `[style]="exp"` and `[class]="exp"` template
+ * bindings. When styles are applied to the Element they will then be placed with respect to
+ * any styles set with `elementStyleProp`. If any styles are set to `null` then they will be
+ * removed from the element.
  *
  * (Note that the styling instruction will not be applied until `elementStylingApply` is called.)
  *
- * @param index Index of the element's styling storage to change in the data array.
- *        (Note that this is not the element index, but rather an index value allocated
- *        specifically for element styling--the index must be the next index after the element
- *        index.)
+ * @param index Index of the element's with which styling is associated.
  * @param classes A key/value style map of CSS classes that will be added to the given element.
  *        Any missing classes (that have already been applied to the element beforehand) will be
  *        removed (unset) from the element's list of CSS classes.
  * @param styles A key/value style map of the styles that will be applied to the given element.
  *        Any missing styles (that have already been applied to the element beforehand) will be
  *        removed (unset) from the element's styling.
- * @param directive the ref to the directive that is attempting to change styling.
+ * @param directive Directive instance that is attempting to change styling. (Defaults to the
+ *        component of the current view).
+ *
+ * @publicApi
  */
 export declare function elementStylingMap<T>(index: number, classes: {
     [key: string]: any;
@@ -442,9 +488,8 @@ export declare function embeddedViewEnd(): void;
  * Refreshes components by entering the component view and processing its bindings, queries, etc.
  *
  * @param adjustedElementIndex  Element index in LView[] (adjusted for HEADER_OFFSET)
- * @param rf  The render flags that should be used to process this template
  */
-export declare function componentRefresh<T>(adjustedElementIndex: number, rf: RenderFlags | null): void;
+export declare function componentRefresh<T>(adjustedElementIndex: number): void;
 /** Returns a boolean for whether the view is attached */
 export declare function viewAttached(view: LView): boolean;
 /**
@@ -532,6 +577,7 @@ export declare function tick<T>(component: T): void;
  * @param component The component which the change detection should be performed on.
  */
 export declare function detectChanges<T>(component: T): void;
+export declare function detectChangesInternal<T>(view: LView, context: T): void;
 /**
  * Synchronously perform change detection on a root view and its components.
  *
@@ -556,7 +602,7 @@ export declare function checkNoChanges<T>(component: T): void;
  */
 export declare function checkNoChangesInRootView(lView: LView): void;
 /** Checks the view of the component provided. Does not gate on dirty checks or execute doCheck. */
-export declare function detectChangesInternal<T>(hostView: LView, component: T, rf: RenderFlags | null): void;
+export declare function checkView<T>(hostView: LView, component: T): void;
 /**
  * Mark the component as dirty (needing change detection).
  *
@@ -668,7 +714,6 @@ export declare function injectAttribute(attrNameToInject: string): string | null
  */
 export declare function registerContentQuery<Q>(queryList: QueryList<Q>, currentDirectiveIndex: number): void;
 export declare const CLEAN_PROMISE: Promise<null>;
-export declare function delegateToClassInput(tNode: TNode): number;
 /**
  * Returns the current OpaqueViewState instance.
  *

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

@@ -18,6 +18,7 @@ export declare const ACTIVE_INDEX = 0;
 export declare const VIEWS = 1;
 export declare const NATIVE = 6;
 export declare const RENDER_PARENT = 7;
+export declare const LCONTAINER_LENGTH = 8;
 /**
  * The state associated with a container.
  *

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

@@ -299,6 +299,3 @@ export declare type PipeDefList = PipeDef<any>[];
 export declare type PipeTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;
 export declare type PipeTypeList = (PipeDef<any> | Type<any>)[];
 export declare const unusedValueExportToPlacateAjd = 1;
-export declare const enum InitialStylingFlags {
-    VALUES_MODE = 1
-}

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

@@ -24,7 +24,6 @@ export interface RelativeInjectorLocation {
 }
 export declare const enum RelativeInjectorLocationFlags {
     InjectorIndexMask = 32767,
-    AcrossHostBoundary = 32768,
     ViewOffsetShift = 16,
     NO_PARENT = -1
 }

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

@@ -45,7 +45,7 @@ export declare const enum TNodeProviderIndexes {
     CptViewProvidersCountShifter = 65536
 }
 /**
- * A set of marker values to be used in the attributes arrays. Those markers indicate that some
+ * A set of marker values to be used in the attributes arrays. These markers indicate that some
  * items are not regular attributes and the processing should be adapted accordingly.
  */
 export declare const enum AttributeMarker {
@@ -55,13 +55,48 @@ export declare const enum AttributeMarker {
      * in that order.
      */
     NamespaceURI = 0,
+    /**
+      * Signals class declaration.
+      *
+      * Each value following `Classes` designates a class name to include on the element.
+      * ## Example:
+      *
+      * Given:
+      * ```
+      * <div class="foo bar baz">...<d/vi>
+      * ```
+      *
+      * the generated code is:
+      * ```
+      * var _c1 = [AttributeMarker.Classes, 'foo', 'bar', 'baz'];
+      * ```
+      */
+    Classes = 1,
+    /**
+     * Signals style declaration.
+     *
+     * Each pair of values following `Styles` designates a style name and value to include on the
+     * element.
+     * ## Example:
+     *
+     * Given:
+     * ```
+     * <div style="width:100px; height:200px; color:red">...</div>
+     * ```
+     *
+     * the generated code is:
+     * ```
+     * var _c1 = [AttributeMarker.Styles, 'width', '100px', 'height'. '200px', 'color', 'red'];
+     * ```
+     */
+    Styles = 2,
     /**
      * This marker indicates that the following attribute names were extracted from bindings (ex.:
      * [foo]="exp") and / or event handlers (ex. (bar)="doSth()").
      * Taking the above bindings and outputs as an example an attributes array could look as follows:
      * ['class', 'fade in', AttributeMarker.SelectOnly, 'foo', 'bar']
      */
-    SelectOnly = 1
+    SelectOnly = 3
 }
 /**
  * A combination of: