@angular/core 9.1.7 → 9.1.11

package/fesm2015/core.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.1.7
+ * @license Angular v9.1.11
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2792,12 +2792,15 @@ const unusedValueExportToPlacateAjd = 1;
  */
 const TYPE = 1;
 /**
- * Below are constants for LContainer indices to help us look up LContainer members
- * without having to remember the specific indices.
- * Uglify will inline these when minifying so there shouldn't be a cost.
+ * Flag to signify that this `LContainer` may have transplanted views which need to be change
+ * detected. (see: `LView[DECLARATION_COMPONENT_VIEW])`.
+ *
+ * This flag, once set, is never unset for the `LContainer`. This means that when unset we can skip
+ * a lot of work in `refreshEmbeddedViews`. But when set we still need to verify
+ * that the `MOVED_VIEWS` are transplanted and on-push.
  * @type {?}
  */
-const ACTIVE_INDEX = 2;
+const HAS_TRANSPLANTED_VIEWS = 2;
 // PARENT, NEXT, TRANSPLANTED_VIEWS_TO_REFRESH are indices 3, 4, and 5
 // As we already have these constants in LView, we don't need to re-create them.
 // T_HOST is index 6
@@ -2816,26 +2819,6 @@ const MOVED_VIEWS = 9;
  * @type {?}
  */
 const CONTAINER_HEADER_OFFSET = 10;
-/** @enum {number} */
-const ActiveIndexFlag = {
-    /**
-     * Flag which signifies that the `LContainer` does not have any inline embedded views.
-     */
-    DYNAMIC_EMBEDDED_VIEWS_ONLY: -1,
-    /**
-     * Flag to signify that this `LContainer` may have transplanted views which need to be change
-     * detected. (see: `LView[DECLARATION_COMPONENT_VIEW])`.
-     *
-     * This flag once set is never unset for the `LContainer`. This means that when unset we can skip
-     * a lot of work in `refreshDynamicEmbeddedViews`. But when set we still need to verify
-     * that the `MOVED_VIEWS` are transplanted and on-push.
-     */
-    HAS_TRANSPLANTED_VIEWS: 1,
-    /**
-     * Number of bits to shift inline embedded views counter to make space for other flags.
-     */
-    SHIFT: 1,
-};
 /**
  * The state associated with a container.
  *
@@ -2852,7 +2835,7 @@ if (false) {
     /* Skipping unnamed member:
     [TYPE]: true;*/
     /* Skipping unnamed member:
-    [ACTIVE_INDEX]: ActiveIndexFlag;*/
+    [HAS_TRANSPLANTED_VIEWS]: boolean;*/
     /* Skipping unnamed member:
     [PARENT]: LView;*/
     /* Skipping unnamed member:
@@ -3782,21 +3765,6 @@ function getConstant(consts, index) {
 function resetPreOrderHookFlags(lView) {
     lView[PREORDER_HOOK_FLAGS] = 0;
 }
-/**
- * @param {?} lContainer
- * @return {?}
- */
-function getLContainerActiveIndex(lContainer) {
-    return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
-}
-/**
- * @param {?} lContainer
- * @param {?} index
- * @return {?}
- */
-function setLContainerActiveIndex(lContainer, index) {
-    lContainer[ACTIVE_INDEX] = index << 1 /* SHIFT */;
-}
 /**
  * Updates the `TRANSPLANTED_VIEWS_TO_REFRESH` counter on the `LContainer` as well as the parents
  * whose
@@ -8708,14 +8676,29 @@ if (false) {
      */
     TNode.prototype.projection;
     /**
-     * A collection of all style static values for an element.
+     * A collection of all `style` static values for an element (including from host).
      *
      * This field will be populated if and when:
      *
-     * - There are one or more initial styles on an element (e.g. `<div style="width:200px">`)
+     * - There are one or more initial `style`s on an element (e.g. `<div style="width:200px;">`)
+     * - There are one or more initial `style`s on a directive/component host
+     *   (e.g. `\@Directive({host: {style: "width:200px;" } }`)
      * @type {?}
      */
     TNode.prototype.styles;
+    /**
+     * A collection of all `style` static values for an element excluding host sources.
+     *
+     * Populated when there are one or more initial `style`s on an element
+     * (e.g. `<div style="width:200px;">`)
+     * Must be stored separately from `tNode.styles` to facilitate setting directive
+     * inputs that shadow the `style` property. If we used `tNode.styles` as is for shadowed inputs,
+     * we would feed host styles back into directives as "inputs". If we used `tNode.attrs`, we would
+     * have to concatenate the attributes on every template pass. Instead, we process once on first
+     * create pass and store here.
+     * @type {?}
+     */
+    TNode.prototype.stylesWithoutHost;
     /**
      * A `KeyValueArray` version of residual `styles`.
      *
@@ -8746,14 +8729,29 @@ if (false) {
      */
     TNode.prototype.residualStyles;
     /**
-     * A collection of all class static values for an element.
+     * A collection of all class static values for an element (including from host).
      *
      * This field will be populated if and when:
      *
      * - There are one or more initial classes on an element (e.g. `<div class="one two three">`)
+     * - There are one or more initial classes on an directive/component host
+     *   (e.g. `\@Directive({host: {class: "SOME_CLASS" } }`)
      * @type {?}
      */
     TNode.prototype.classes;
+    /**
+     * A collection of all class static values for an element excluding host sources.
+     *
+     * Populated when there are one or more initial classes on an element
+     * (e.g. `<div class="SOME_CLASS">`)
+     * Must be stored separately from `tNode.classes` to facilitate setting directive
+     * inputs that shadow the `class` property. If we used `tNode.classes` as is for shadowed inputs,
+     * we would feed host classes back into directives as "inputs". If we used `tNode.attrs`, we would
+     * have to concatenate the attributes on every template pass. Instead, we process once on first
+     * create pass and store here.
+     * @type {?}
+     */
+    TNode.prototype.classesWithoutHost;
     /**
      * A `KeyValueArray` version of residual `classes`.
      *
@@ -9650,6 +9648,32 @@ function getRootContext(viewOrComponent) {
         assertDefined(rootView[CONTEXT], 'RootView has no context. Perhaps it is disconnected?');
     return (/** @type {?} */ (rootView[CONTEXT]));
 }
+/**
+ * Gets the first `LContainer` in the LView or `null` if none exists.
+ * @param {?} lView
+ * @return {?}
+ */
+function getFirstLContainer(lView) {
+    return getNearestLContainer(lView[CHILD_HEAD]);
+}
+/**
+ * Gets the next `LContainer` that is a sibling of the given container.
+ * @param {?} container
+ * @return {?}
+ */
+function getNextLContainer(container) {
+    return getNearestLContainer(container[NEXT]);
+}
+/**
+ * @param {?} viewOrContainer
+ * @return {?}
+ */
+function getNearestLContainer(viewOrContainer) {
+    while (viewOrContainer !== null && !isLContainer(viewOrContainer)) {
+        viewOrContainer = viewOrContainer[NEXT];
+    }
+    return viewOrContainer;
+}
 
 /**
  * @fileoverview added by tsickle
@@ -10587,8 +10611,10 @@ class TNode$1 {
      * @param {?} parent
      * @param {?} projection
      * @param {?} styles
+     * @param {?} stylesWithoutHost
      * @param {?} residualStyles
      * @param {?} classes
+     * @param {?} classesWithoutHost
      * @param {?} residualClasses
      * @param {?} classBindings
      * @param {?} styleBindings
@@ -10617,8 +10643,10 @@ class TNode$1 {
     parent, //
     projection, //
     styles, //
+    stylesWithoutHost, //
     residualStyles, //
     classes, //
+    classesWithoutHost, //
     residualClasses, //
     classBindings, //
     styleBindings) {
@@ -10646,8 +10674,10 @@ class TNode$1 {
         this.parent = parent;
         this.projection = projection;
         this.styles = styles;
+        this.stylesWithoutHost = stylesWithoutHost;
         this.residualStyles = residualStyles;
         this.classes = classes;
+        this.classesWithoutHost = classesWithoutHost;
         this.residualClasses = residualClasses;
         this.classBindings = classBindings;
         this.styleBindings = styleBindings;
@@ -10784,10 +10814,14 @@ if (false) {
     /** @type {?} */
     TNode$1.prototype.styles;
     /** @type {?} */
+    TNode$1.prototype.stylesWithoutHost;
+    /** @type {?} */
     TNode$1.prototype.residualStyles;
     /** @type {?} */
     TNode$1.prototype.classes;
     /** @type {?} */
+    TNode$1.prototype.classesWithoutHost;
+    /** @type {?} */
     TNode$1.prototype.residualClasses;
     /** @type {?} */
     TNode$1.prototype.classBindings;
@@ -11195,18 +11229,11 @@ class LContainerDebug {
     constructor(_raw_lContainer) {
         this._raw_lContainer = _raw_lContainer;
     }
-    /**
-     * @return {?}
-     */
-    get activeIndex() {
-        return getLContainerActiveIndex(this._raw_lContainer);
-    }
     /**
      * @return {?}
      */
     get hasTransplantedViews() {
-        return (this._raw_lContainer[ACTIVE_INDEX] & 1 /* HAS_TRANSPLANTED_VIEWS */) ===
-            1 /* HAS_TRANSPLANTED_VIEWS */;
+        return this._raw_lContainer[HAS_TRANSPLANTED_VIEWS];
     }
     /**
      * @return {?}
@@ -11832,7 +11859,7 @@ function assignTViewNodeToLView(tView, tParentNode, index, lView) {
         tView.node = tNode = (/** @type {?} */ (createTNode(tView, (/** @type {?} */ (tParentNode)), //
         2 /* View */, index, null, null)));
     }
-    return lView[T_HOST] = (/** @type {?} */ (tNode));
+    lView[T_HOST] = (/** @type {?} */ (tNode));
 }
 /**
  * When elements are created dynamically after a view blueprint is created (e.g. through
@@ -11992,7 +12019,7 @@ function refreshView(tView, lView, templateFn, context) {
         // insertion points. This is needed to avoid the situation where the template is defined in this
         // `LView` but its declaration appears after the insertion component.
         markTransplantedViewsForRefresh(lView);
-        refreshDynamicEmbeddedViews(lView);
+        refreshEmbeddedViews(lView);
         // Content query results must be refreshed before content hooks are called.
         if (tView.contentQueries !== null) {
             refreshContentQueries(tView, lView);
@@ -12446,8 +12473,10 @@ function createTNode(tView, tParent, type, adjustedIndex, tagName, attrs) {
     tParent, // parent: TElementNode|TContainerNode|null
     null, // projection: number|(ITNode|RNode[])[]|null
     null, // styles: string|null
+    null, // stylesWithoutHost: string|null
     undefined, // residualStyles: string|null
     null, // classes: string|null
+    null, // classesWithoutHost: string|null
     undefined, (/** @type {?} */ (0)), (/** @type {?} */ (0))) :
         {
             type: type,
@@ -12473,8 +12502,10 @@ function createTNode(tView, tParent, type, adjustedIndex, tagName, attrs) {
             parent: tParent,
             projection: null,
             styles: null,
+            stylesWithoutHost: null,
             residualStyles: undefined,
             classes: null,
+            classesWithoutHost: null,
             residualClasses: undefined,
             classBindings: (/** @type {?} */ (0)),
             styleBindings: (/** @type {?} */ (0)),
@@ -13329,7 +13360,7 @@ function createLContainer(hostNative, currentView, native, tNode) {
     /** @type {?} */
     const lContainer = new (ngDevMode ? LContainerArray : Array)(hostNative, // host native
     true, // Boolean `true` in this position signifies that this is an `LContainer`
-    -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */ << 1 /* SHIFT */, // active index
+    false, // has transplanted views
     currentView, // parent
     null, // next
     0, // transplanted views to refresh count
@@ -13343,12 +13374,12 @@ function createLContainer(hostNative, currentView, native, tNode) {
     return lContainer;
 }
 /**
- * Goes over dynamic embedded views (ones created through ViewContainerRef APIs) and refreshes
+ * Goes over embedded views (ones created through ViewContainerRef APIs) and refreshes
  * them by executing an associated template function.
  * @param {?} lView
  * @return {?}
  */
-function refreshDynamicEmbeddedViews(lView) {
+function refreshEmbeddedViews(lView) {
     for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
         for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
             /** @type {?} */
@@ -13362,70 +13393,35 @@ function refreshDynamicEmbeddedViews(lView) {
         }
     }
 }
-/**
- * Gets the first `LContainer` in the LView or `null` if none exists.
- * @param {?} lView
- * @return {?}
- */
-function getFirstLContainer(lView) {
-    /** @type {?} */
-    let viewOrContainer = lView[CHILD_HEAD];
-    while (viewOrContainer !== null &&
-        !(isLContainer(viewOrContainer) &&
-            viewOrContainer[ACTIVE_INDEX] >> 1 /* SHIFT */ ===
-                -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */)) {
-        viewOrContainer = viewOrContainer[NEXT];
-    }
-    return viewOrContainer;
-}
-/**
- * Gets the next `LContainer` that is a sibling of the given container.
- * @param {?} container
- * @return {?}
- */
-function getNextLContainer(container) {
-    /** @type {?} */
-    let viewOrContainer = container[NEXT];
-    while (viewOrContainer !== null &&
-        !(isLContainer(viewOrContainer) &&
-            viewOrContainer[ACTIVE_INDEX] >> 1 /* SHIFT */ ===
-                -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */)) {
-        viewOrContainer = viewOrContainer[NEXT];
-    }
-    return viewOrContainer;
-}
 /**
  * Mark transplanted views as needing to be refreshed at their insertion points.
  *
- * See: `ActiveIndexFlag.HAS_TRANSPLANTED_VIEWS` and `LView[DECLARATION_COMPONENT_VIEW]` for
- * explanation of transplanted views.
- *
  * @param {?} lView The `LView` that may have transplanted views.
  * @return {?}
  */
 function markTransplantedViewsForRefresh(lView) {
     for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
-        if ((lContainer[ACTIVE_INDEX] & 1 /* HAS_TRANSPLANTED_VIEWS */) !== 0) {
+        if (!lContainer[HAS_TRANSPLANTED_VIEWS])
+            continue;
+        /** @type {?} */
+        const movedViews = (/** @type {?} */ (lContainer[MOVED_VIEWS]));
+        ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
+        for (let i = 0; i < movedViews.length; i++) {
             /** @type {?} */
-            const movedViews = (/** @type {?} */ (lContainer[MOVED_VIEWS]));
-            ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
-            for (let i = 0; i < movedViews.length; i++) {
-                /** @type {?} */
-                const movedLView = (/** @type {?} */ (movedViews[i]));
-                /** @type {?} */
-                const insertionLContainer = (/** @type {?} */ (movedLView[PARENT]));
-                ngDevMode && assertLContainer(insertionLContainer);
-                // We don't want to increment the counter if the moved LView was already marked for
-                // refresh.
-                if ((movedLView[FLAGS] & 1024 /* RefreshTransplantedView */) === 0) {
-                    updateTransplantedViewCount(insertionLContainer, 1);
-                }
-                // Note, it is possible that the `movedViews` is tracking views that are transplanted *and*
-                // those that aren't (declaration component === insertion component). In the latter case,
-                // it's fine to add the flag, as we will clear it immediately in
-                // `refreshDynamicEmbeddedViews` for the view currently being refreshed.
-                movedLView[FLAGS] |= 1024 /* RefreshTransplantedView */;
+            const movedLView = (/** @type {?} */ (movedViews[i]));
+            /** @type {?} */
+            const insertionLContainer = (/** @type {?} */ (movedLView[PARENT]));
+            ngDevMode && assertLContainer(insertionLContainer);
+            // We don't want to increment the counter if the moved LView was already marked for
+            // refresh.
+            if ((movedLView[FLAGS] & 1024 /* RefreshTransplantedView */) === 0) {
+                updateTransplantedViewCount(insertionLContainer, 1);
             }
+            // Note, it is possible that the `movedViews` is tracking views that are transplanted *and*
+            // those that aren't (declaration component === insertion component). In the latter case,
+            // it's fine to add the flag, as we will clear it immediately in
+            // `refreshEmbeddedViews` for the view currently being refreshed.
+            movedLView[FLAGS] |= 1024 /* RefreshTransplantedView */;
         }
     }
 }
@@ -14154,7 +14150,7 @@ function trackMovedView(declarationContainer, lView) {
         // At this point the declaration-component is not same as insertion-component; this means that
         // this is a transplanted view. Mark the declared lView as having transplanted views so that
         // those views can participate in CD.
-        declarationContainer[ACTIVE_INDEX] |= 1 /* HAS_TRANSPLANTED_VIEWS */;
+        declarationContainer[HAS_TRANSPLANTED_VIEWS] = true;
     }
     if (movedViews === null) {
         declarationContainer[MOVED_VIEWS] = [lView];
@@ -15080,10 +15076,6 @@ class ViewRef {
         this._cdRefInjectingView = _cdRefInjectingView;
         this._appRef = null;
         this._viewContainerRef = null;
-        /**
-         * \@internal
-         */
-        this._tViewNode = null;
     }
     /**
      * @return {?}
@@ -15361,11 +15353,6 @@ if (false) {
      * @private
      */
     ViewRef.prototype._viewContainerRef;
-    /**
-     * \@internal
-     * @type {?}
-     */
-    ViewRef.prototype._tViewNode;
     /**
      * This represents `LView` associated with the component when ViewRef is a ChangeDetectorRef.
      *
@@ -15574,10 +15561,7 @@ function createTemplateRef(TemplateRefToken, ElementRefToken, hostTNode, hostVie
                     embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);
                 }
                 renderView(embeddedTView, embeddedLView, context);
-                /** @type {?} */
-                const viewRef = new ViewRef(embeddedLView);
-                viewRef._tViewNode = (/** @type {?} */ (embeddedLView[T_HOST]));
-                return viewRef;
+                return new ViewRef(embeddedLView);
             }
         };
     }
@@ -15844,7 +15828,6 @@ function createContainerRef(ViewContainerRefToken, ElementRefToken, hostTNode, h
     if (isLContainer(slotValue)) {
         // If the host is a container, we don't need to create a new LContainer
         lContainer = slotValue;
-        setLContainerActiveIndex(lContainer, -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */);
     }
     else {
         /** @type {?} */
@@ -16126,7 +16109,7 @@ function isType(v) {
 const DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*arguments\)/;
 const INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
 const INHERITED_CLASS_WITH_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/;
-const INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{\s+super\(\.\.\.arguments\)/;
+const INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{\s*super\(\.\.\.arguments\)/;
 /**
  * Determine whether a stringified type is a class which delegates its constructor
  * to its parent.
@@ -19791,36 +19774,41 @@ function componentDefResolved(type) {
  *
  * @param {?} tNode The `TNode` into which the styling information should be loaded.
  * @param {?} attrs `TAttributes` containing the styling information.
+ * @param {?} writeToHost Where should the resulting static styles be written?
+ *   - `false` Write to `TNode.stylesWithoutHost` / `TNode.classesWithoutHost`
+ *   - `true` Write to `TNode.styles` / `TNode.classes`
  * @return {?}
  */
-function computeStaticStyling(tNode, attrs) {
+function computeStaticStyling(tNode, attrs, writeToHost) {
     ngDevMode &&
         assertFirstCreatePass(getTView(), 'Expecting to be called in first template pass only');
     /** @type {?} */
-    let styles = tNode.styles;
+    let styles = writeToHost ? tNode.styles : null;
     /** @type {?} */
-    let classes = tNode.classes;
+    let classes = writeToHost ? tNode.classes : null;
     /** @type {?} */
     let mode = 0;
-    for (let i = 0; i < attrs.length; i++) {
-        /** @type {?} */
-        const value = attrs[i];
-        if (typeof value === 'number') {
-            mode = value;
-        }
-        else if (mode == 1 /* Classes */) {
-            classes = concatStringsWithSpace(classes, (/** @type {?} */ (value)));
-        }
-        else if (mode == 2 /* Styles */) {
-            /** @type {?} */
-            const style = (/** @type {?} */ (value));
+    if (attrs !== null) {
+        for (let i = 0; i < attrs.length; i++) {
             /** @type {?} */
-            const styleValue = (/** @type {?} */ (attrs[++i]));
-            styles = concatStringsWithSpace(styles, style + ': ' + styleValue + ';');
+            const value = attrs[i];
+            if (typeof value === 'number') {
+                mode = value;
+            }
+            else if (mode == 1 /* Classes */) {
+                classes = concatStringsWithSpace(classes, (/** @type {?} */ (value)));
+            }
+            else if (mode == 2 /* Styles */) {
+                /** @type {?} */
+                const style = (/** @type {?} */ (value));
+                /** @type {?} */
+                const styleValue = (/** @type {?} */ (attrs[++i]));
+                styles = concatStringsWithSpace(styles, style + ': ' + styleValue + ';');
+            }
         }
     }
-    styles !== null && (tNode.styles = styles);
-    classes !== null && (tNode.classes = classes);
+    writeToHost ? tNode.styles = styles : tNode.stylesWithoutHost = styles;
+    writeToHost ? tNode.classes = classes : tNode.classesWithoutHost = classes;
 }
 
 /**
@@ -21228,8 +21216,11 @@ function elementStartFirstCreatePass(index, tView, lView, native, name, attrsInd
     /** @type {?} */
     const hasDirectives = resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
     ngDevMode && warnAboutUnknownElement(tView, lView, native, tNode, hasDirectives);
+    if (tNode.attrs !== null) {
+        computeStaticStyling(tNode, tNode.attrs, false);
+    }
     if (tNode.mergedAttrs !== null) {
-        computeStaticStyling(tNode, tNode.mergedAttrs);
+        computeStaticStyling(tNode, tNode.mergedAttrs, true);
     }
     if (tView.queries !== null) {
         tView.queries.elementStart(tView, tNode);
@@ -21332,11 +21323,11 @@ function ɵɵelementEnd() {
             (/** @type {?} */ (tView.queries)).elementEnd(previousOrParentTNode);
         }
     }
-    if (tNode.classes !== null && hasClassInput(tNode)) {
-        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classes, true);
+    if (tNode.classesWithoutHost != null && hasClassInput(tNode)) {
+        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classesWithoutHost, true);
     }
-    if (tNode.styles !== null && hasStyleInput(tNode)) {
-        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.styles, false);
+    if (tNode.stylesWithoutHost != null && hasStyleInput(tNode)) {
+        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.stylesWithoutHost, false);
     }
 }
 /**
@@ -21426,7 +21417,7 @@ function elementContainerStartFirstCreatePass(index, tView, lView, attrsIndex, l
     // While ng-container doesn't necessarily support styling, we use the style context to identify
     // and execute directives on the ng-container.
     if (attrs !== null) {
-        computeStaticStyling(tNode, attrs);
+        computeStaticStyling(tNode, attrs, true);
     }
     /** @type {?} */
     const localRefs = getConstant(tViewConsts, localRefsIndex);
@@ -23539,7 +23530,7 @@ function checkStylingMap(keyValueArraySet, stringParser, value, isClassBased) {
             // thing as it would think that the static portion was removed. For this reason we
             // concatenate it so that `[ngStyle]`/`[ngClass]`  can continue to work on changed.
             /** @type {?} */
-            let staticPrefix = isClassBased ? tNode.classes : tNode.styles;
+            let staticPrefix = isClassBased ? tNode.classesWithoutHost : tNode.stylesWithoutHost;
             ngDevMode && isClassBased === false && staticPrefix !== null &&
                 assertEqual(staticPrefix.endsWith(';'), true, 'Expecting static portion to end with \';\'');
             if (staticPrefix !== null) {
@@ -26441,7 +26432,7 @@ function createRootComponentView(rNode, def, rootView, rendererFactory, hostRend
     /** @type {?} */
     const mergedAttrs = tNode.mergedAttrs = def.hostAttrs;
     if (mergedAttrs !== null) {
-        computeStaticStyling(tNode, mergedAttrs);
+        computeStaticStyling(tNode, mergedAttrs, true);
         if (rNode !== null) {
             setUpAttributes(hostRenderer, rNode, mergedAttrs);
             if (tNode.classes !== null) {
@@ -28178,7 +28169,7 @@ if (false) {
  * \@publicApi
  * @type {?}
  */
-const VERSION = new Version('9.1.7');
+const VERSION = new Version('9.1.11');
 
 /**
  * @fileoverview added by tsickle
@@ -34114,7 +34105,8 @@ class ComponentFactory$1 extends ComponentFactory {
         if (!rootSelectorOrNode || isIsolated) {
             // The host element of the internal or isolated root view is attached to the component's host
             // view node.
-            (/** @type {?} */ (componentRef.hostView._tViewNode)).child = tElementNode;
+            ngDevMode && assertNodeOfPossibleTypes(rootTView.node, 2 /* View */);
+            (/** @type {?} */ (rootTView.node)).child = tElementNode;
         }
         return componentRef;
     }
@@ -34176,7 +34168,7 @@ class ComponentRef$1 extends ComponentRef {
         this.destroyCbs = [];
         this.instance = instance;
         this.hostView = this.changeDetectorRef = new RootViewRef(_rootLView);
-        this.hostView._tViewNode = assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);
+        assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);
         this.componentType = componentType;
     }
     /**