@angular/core 9.1.3 → 9.1.7

package/bundles/core.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.1.3
+ * @license Angular v9.1.7
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2087,7 +2087,7 @@
     var FLAGS = 2;
     var PARENT = 3;
     var NEXT = 4;
-    var QUERIES = 5;
+    var TRANSPLANTED_VIEWS_TO_REFRESH = 5;
     var T_HOST = 6;
     var CLEANUP = 7;
     var CONTEXT = 8;
@@ -2101,8 +2101,9 @@
     var DECLARATION_COMPONENT_VIEW = 16;
     var DECLARATION_LCONTAINER = 17;
     var PREORDER_HOOK_FLAGS = 18;
+    var QUERIES = 19;
     /** Size of LView's header. Necessary to adjust for it when setting slots.  */
-    var HEADER_OFFSET = 19;
+    var HEADER_OFFSET = 20;
     // Note: This hack is necessary so we don't erroneously get a circular dependency
     // failure based on types.
     var unusedValueExportToPlacateAjd = 1;
@@ -2126,20 +2127,20 @@
      * Uglify will inline these when minifying so there shouldn't be a cost.
      */
     var ACTIVE_INDEX = 2;
-    // PARENT and NEXT are indices 3 and 4
+    // 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.
-    var MOVED_VIEWS = 5;
     // T_HOST is index 6
     // We already have this constants in LView, we don't need to re-create it.
     var NATIVE = 7;
     var VIEW_REFS = 8;
+    var MOVED_VIEWS = 9;
     /**
      * Size of LContainer's header. Represents the index after which all views in the
      * container will be inserted. We need to keep a record of current views so we know
      * which views are already in the DOM (and don't need to be re-added) and so we can
      * remove views from the DOM when they are no longer required.
      */
-    var CONTAINER_HEADER_OFFSET = 9;
+    var CONTAINER_HEADER_OFFSET = 10;
     // Note: This hack is necessary so we don't erroneously get a circular dependency
     // failure based on types.
     var unusedValueExportToPlacateAjd$1 = 1;
@@ -2218,9 +2219,6 @@
             arr = lView;
         assertEqual(arr.length, index, "index " + index + " expected to be at the end of arr (length " + arr.length + ")");
     }
-    function assertLContainerOrUndefined(value) {
-        value && assertEqual(isLContainer(value), true, 'Expecting LContainer or undefined or null');
-    }
     function assertLContainer(value) {
         assertDefined(value, 'LContainer must be defined');
         assertEqual(isLContainer(value), true, 'Expecting LContainer');
@@ -2519,6 +2517,25 @@
     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
+     *  1. counter goes from 0 to 1, indicating that there is a new child that has a view to refresh
+     *  or
+     *  2. counter goes from 1 to 0, indicating there are no more descendant views to refresh
+     */
+    function updateTransplantedViewCount(lContainer, amount) {
+        lContainer[TRANSPLANTED_VIEWS_TO_REFRESH] += amount;
+        var viewOrContainer = lContainer;
+        var parent = lContainer[PARENT];
+        while (parent !== null &&
+            ((amount === 1 && viewOrContainer[TRANSPLANTED_VIEWS_TO_REFRESH] === 1) ||
+                (amount === -1 && viewOrContainer[TRANSPLANTED_VIEWS_TO_REFRESH] === 0))) {
+            parent[TRANSPLANTED_VIEWS_TO_REFRESH] += amount;
+            viewOrContainer = parent;
+            parent = parent[PARENT];
+        }
+    }
 
     /**
      * @license
@@ -2678,7 +2695,7 @@
     function setBindingRootForHostBindings(bindingRootIndex, currentDirectiveIndex) {
         var lFrame = instructionState.lFrame;
         lFrame.bindingIndex = lFrame.bindingRootIndex = bindingRootIndex;
-        lFrame.currentDirectiveIndex = currentDirectiveIndex;
+        setCurrentDirectiveIndex(currentDirectiveIndex);
     }
     /**
      * When host binding is executing this points to the directive index.
@@ -2688,6 +2705,24 @@
     function getCurrentDirectiveIndex() {
         return instructionState.lFrame.currentDirectiveIndex;
     }
+    /**
+     * Sets an index of a directive whose `hostBindings` are being processed.
+     *
+     * @param currentDirectiveIndex `TData` index where current directive instance can be found.
+     */
+    function setCurrentDirectiveIndex(currentDirectiveIndex) {
+        instructionState.lFrame.currentDirectiveIndex = currentDirectiveIndex;
+    }
+    /**
+     * Retrieve the current `DirectiveDef` which is active when `hostBindings` instruction is being
+     * executed.
+     *
+     * @param tData Current `TData` where the `DirectiveDef` will be looked up at.
+     */
+    function getCurrentDirectiveDef(tData) {
+        var currentDirectiveIndex = instructionState.lFrame.currentDirectiveIndex;
+        return currentDirectiveIndex === -1 ? null : tData[currentDirectiveIndex];
+    }
     function getCurrentQueryIndex() {
         return instructionState.lFrame.currentQueryIndex;
     }
@@ -3045,7 +3080,7 @@
             assertNotEqual(initPhase, 3 /* InitPhaseCompleted */, 'Init hooks phase should not be incremented after all init hooks have been run.');
         var flags = lView[FLAGS];
         if ((flags & 3 /* InitPhaseStateMask */) === initPhase) {
-            flags &= 1023 /* IndexWithinInitPhaseReset */;
+            flags &= 2047 /* IndexWithinInitPhaseReset */;
             flags += 1 /* InitPhaseStateIncrementer */;
             lView[FLAGS] = flags;
         }
@@ -3108,13 +3143,13 @@
         var directiveIndex = isInitHook ? -arr[i] : arr[i];
         var directive = currentView[directiveIndex];
         if (isInitHook) {
-            var indexWithintInitPhase = currentView[FLAGS] >> 10 /* IndexWithinInitPhaseShift */;
+            var indexWithintInitPhase = currentView[FLAGS] >> 11 /* IndexWithinInitPhaseShift */;
             // The init phase state must be always checked here as it may have been recursively
             // updated
             if (indexWithintInitPhase <
                 (currentView[PREORDER_HOOK_FLAGS] >> 16 /* NumberOfInitHooksCalledShift */) &&
                 (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhase) {
-                currentView[FLAGS] += 1024 /* IndexWithinInitPhaseIncrementer */;
+                currentView[FLAGS] += 2048 /* IndexWithinInitPhaseIncrementer */;
                 hook.call(directive);
             }
         }
@@ -6660,7 +6695,9 @@
         pipeRegistry, //
         firstChild, //
         schemas, //
-        consts) {
+        consts, //
+        incompleteFirstPass //
+        ) {
             this.type = type;
             this.id = id;
             this.blueprint = blueprint;
@@ -6691,6 +6728,7 @@
             this.firstChild = firstChild;
             this.schemas = schemas;
             this.consts = consts;
+            this.incompleteFirstPass = incompleteFirstPass;
         }
         Object.defineProperty(TView.prototype, "template_", {
             get: function () {
@@ -6967,7 +7005,7 @@
                     attached: !!(flags & 128 /* Attached */),
                     destroyed: !!(flags & 256 /* Destroyed */),
                     isRoot: !!(flags & 512 /* IsRoot */),
-                    indexWithinInitPhase: flags >> 10 /* IndexWithinInitPhaseShift */,
+                    indexWithinInitPhase: flags >> 11 /* IndexWithinInitPhaseShift */,
                 };
             },
             enumerable: true,
@@ -7702,6 +7740,14 @@
                 renderChildComponents(lView, components);
             }
         }
+        catch (error) {
+            // If we didn't manage to get past the first template pass due to
+            // an error, mark the view as corrupted so we can try to recover.
+            if (tView.firstCreatePass) {
+                tView.incompleteFirstPass = true;
+            }
+            throw error;
+        }
         finally {
             lView[FLAGS] &= ~4 /* CreationMode */;
             leaveView();
@@ -7746,6 +7792,10 @@
                     incrementInitPhaseFlags(lView, 0 /* OnInitHooksToBeRun */);
                 }
             }
+            // First mark transplanted views that are declared in this lView as needing a refresh at their
+            // 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);
             // Content query results must be refreshed before content hooks are called.
             if (tView.contentQueries !== null) {
@@ -7816,6 +7866,10 @@
             if (!checkNoChangesMode) {
                 lView[FLAGS] &= ~(64 /* Dirty */ | 8 /* FirstLViewPass */);
             }
+            if (lView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+                lView[FLAGS] &= ~1024 /* RefreshTransplantedView */;
+                updateTransplantedViewCount(lView[PARENT], -1);
+            }
         }
         finally {
             leaveView();
@@ -7907,8 +7961,13 @@
      * @returns TView
      */
     function getOrCreateTComponentView(def) {
-        return def.tView ||
-            (def.tView = createTView(1 /* Component */, -1, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts));
+        var tView = def.tView;
+        // Create a TView if there isn't one, or recreate it if the first create pass didn't
+        // complete successfuly since we can't know for sure whether it's in a usable shape.
+        if (tView === null || tView.incompleteFirstPass) {
+            return def.tView = createTView(1 /* Component */, -1, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts);
+        }
+        return tView;
     }
     /**
      * Creates a TView instance
@@ -7961,7 +8020,9 @@
             typeof pipes === 'function' ? pipes() : pipes, // pipeRegistry: PipeDefList|null,
             null, // firstChild: TNode|null,
             schemas, // schemas: SchemaMetadata[]|null,
-            consts) : // consts: TConstants|null
+            consts, // consts: TConstants|null
+            false // incompleteFirstPass: boolean
+            ) :
             {
                 type: type,
                 id: viewIndex,
@@ -7993,6 +8054,7 @@
                 firstChild: null,
                 schemas: schemas,
                 consts: consts,
+                incompleteFirstPass: false
             };
     }
     function createViewBlueprint(bindingStartIndex, initialViewLength) {
@@ -8514,11 +8576,13 @@
         var expando = tView.expandoInstructions;
         var firstCreatePass = tView.firstCreatePass;
         var elementIndex = tNode.index - HEADER_OFFSET;
+        var currentDirectiveIndex = getCurrentDirectiveIndex();
         try {
             setSelectedIndex(elementIndex);
-            for (var i = start; i < end; i++) {
-                var def = tView.data[i];
-                var directive = lView[i];
+            for (var dirIndex = start; dirIndex < end; dirIndex++) {
+                var def = tView.data[dirIndex];
+                var directive = lView[dirIndex];
+                setCurrentDirectiveIndex(dirIndex);
                 if (def.hostBindings !== null || def.hostVars !== 0 || def.hostAttrs !== null) {
                     invokeHostBindingsInCreationMode(def, directive);
                 }
@@ -8529,6 +8593,7 @@
         }
         finally {
             setSelectedIndex(-1);
+            setCurrentDirectiveIndex(currentDirectiveIndex);
         }
     }
     /**
@@ -8782,10 +8847,13 @@
         -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */ << 1 /* SHIFT */, // active index
         currentView, // parent
         null, // next
-        null, // queries
+        0, // transplanted views to refresh count
         tNode, // t_host
         native, // native,
+        null, // view refs
         null);
+        ngDevMode &&
+            assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, 'Should allocate correct number of slots for LContainer header.');
         ngDevMode && attachLContainerDebug(lContainer);
         return lContainer;
     }
@@ -8794,66 +8862,70 @@
      * them by executing an associated template function.
      */
     function refreshDynamicEmbeddedViews(lView) {
-        var viewOrContainer = lView[CHILD_HEAD];
-        while (viewOrContainer !== null) {
-            // Note: viewOrContainer can be an LView or an LContainer instance, but here we are only
-            // interested in LContainer
-            var activeIndexFlag = void 0;
-            if (isLContainer(viewOrContainer) &&
-                (activeIndexFlag = viewOrContainer[ACTIVE_INDEX]) >> 1 /* SHIFT */ ===
-                    -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */) {
-                for (var i = CONTAINER_HEADER_OFFSET; i < viewOrContainer.length; i++) {
-                    var embeddedLView = viewOrContainer[i];
-                    var embeddedTView = embeddedLView[TVIEW];
-                    ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
-                    if (viewAttachedToChangeDetector(embeddedLView)) {
-                        refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
-                    }
-                }
-                if ((activeIndexFlag & 1 /* HAS_TRANSPLANTED_VIEWS */) !== 0) {
-                    // We should only CD moved views if the component where they were inserted does not match
-                    // the component where they were declared and insertion is on-push. Moved views also
-                    // contains intra component moves, or check-always which need to be skipped.
-                    refreshTransplantedViews(viewOrContainer, lView[DECLARATION_COMPONENT_VIEW]);
+        for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+            for (var i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+                var embeddedLView = lContainer[i];
+                var embeddedTView = embeddedLView[TVIEW];
+                ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
+                if (viewAttachedToChangeDetector(embeddedLView)) {
+                    refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
                 }
             }
+        }
+    }
+    /**
+     * Gets the first `LContainer` in the LView or `null` if none exists.
+     */
+    function getFirstLContainer(lView) {
+        var viewOrContainer = lView[CHILD_HEAD];
+        while (viewOrContainer !== null &&
+            !(isLContainer(viewOrContainer) &&
+                viewOrContainer[ACTIVE_INDEX] >> 1 /* SHIFT */ ===
+                    -1 /* DYNAMIC_EMBEDDED_VIEWS_ONLY */)) {
             viewOrContainer = viewOrContainer[NEXT];
         }
+        return viewOrContainer;
     }
     /**
-     * Refresh transplanted LViews.
+     * Gets the next `LContainer` that is a sibling of the given container.
+     */
+    function getNextLContainer(container) {
+        var 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 lContainer The `LContainer` which has transplanted views.
-     * @param declaredComponentLView The `lContainer` parent component `LView`.
-     */
-    function refreshTransplantedViews(lContainer, declaredComponentLView) {
-        var movedViews = lContainer[MOVED_VIEWS];
-        ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
-        for (var i = 0; i < movedViews.length; i++) {
-            var movedLView = movedViews[i];
-            var insertionLContainer = movedLView[PARENT];
-            ngDevMode && assertLContainer(insertionLContainer);
-            var insertedComponentLView = insertionLContainer[PARENT][DECLARATION_COMPONENT_VIEW];
-            ngDevMode && assertDefined(insertedComponentLView, 'Missing LView');
-            // Check if we have a transplanted view by compering declaration and insertion location.
-            if (insertedComponentLView !== declaredComponentLView) {
-                // Yes the `LView` is transplanted.
-                // Here we would like to know if the component is `OnPush`. We don't have
-                // explicit `OnPush` flag instead we set `CheckAlways` to false (which is `OnPush`)
-                // Not to be confused with `ManualOnPush` which is used with wether a DOM event
-                // should automatically mark a view as dirty.
-                var insertionComponentIsOnPush = (insertedComponentLView[FLAGS] & 16 /* CheckAlways */) === 0;
-                if (insertionComponentIsOnPush) {
-                    // Here we know that the template has been transplanted across components and is
-                    // on-push (not just moved within a component). If the insertion is marked dirty, then
-                    // there is no need to CD here as we will do it again later when we get to insertion
-                    // point.
-                    var movedTView = movedLView[TVIEW];
-                    ngDevMode && assertDefined(movedTView, 'TView must be allocated');
-                    refreshView(movedTView, movedLView, movedTView.template, movedLView[CONTEXT]);
+     * @param lView The `LView` that may have transplanted views.
+     */
+    function markTransplantedViewsForRefresh(lView) {
+        for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+            if ((lContainer[ACTIVE_INDEX] & 1 /* HAS_TRANSPLANTED_VIEWS */) !== 0) {
+                var movedViews = lContainer[MOVED_VIEWS];
+                ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
+                for (var i = 0; i < movedViews.length; i++) {
+                    var movedLView = movedViews[i];
+                    var insertionLContainer = 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 */;
                 }
             }
         }
@@ -8868,10 +8940,49 @@
         ngDevMode && assertEqual(isCreationMode(hostLView), false, 'Should be run in update mode');
         var componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
         // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
-        if (viewAttachedToChangeDetector(componentView) &&
-            componentView[FLAGS] & (16 /* CheckAlways */ | 64 /* Dirty */)) {
-            var componentTView = componentView[TVIEW];
-            refreshView(componentTView, componentView, componentTView.template, componentView[CONTEXT]);
+        if (viewAttachedToChangeDetector(componentView)) {
+            var tView = componentView[TVIEW];
+            if (componentView[FLAGS] & (16 /* CheckAlways */ | 64 /* Dirty */)) {
+                refreshView(tView, componentView, tView.template, componentView[CONTEXT]);
+            }
+            else if (componentView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {
+                // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
+                refreshContainsDirtyView(componentView);
+            }
+        }
+    }
+    /**
+     * Refreshes all transplanted views marked with `LViewFlags.RefreshTransplantedView` that are
+     * children or descendants of the given lView.
+     *
+     * @param lView The lView which contains descendant transplanted views that need to be refreshed.
+     */
+    function refreshContainsDirtyView(lView) {
+        for (var lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+            for (var i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+                var embeddedLView = lContainer[i];
+                if (embeddedLView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+                    var embeddedTView = embeddedLView[TVIEW];
+                    ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
+                    refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
+                }
+                else if (embeddedLView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {
+                    refreshContainsDirtyView(embeddedLView);
+                }
+            }
+        }
+        var tView = lView[TVIEW];
+        // Refresh child component views.
+        var components = tView.components;
+        if (components !== null) {
+            for (var i = 0; i < components.length; i++) {
+                var componentView = getComponentLViewByIndex(components[i], lView);
+                // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
+                if (viewAttachedToChangeDetector(componentView) &&
+                    componentView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {
+                    refreshContainsDirtyView(componentView);
+                }
+            }
         }
     }
     function renderComponent(hostLView, componentHostIdx) {
@@ -9120,9 +9231,17 @@
      * There are cases where the sub component's renderer needs to be included
      * instead of the current renderer (see the componentSyntheticHost* instructions).
      */
-    function loadComponentRenderer(tNode, lView) {
-        var componentLView = unwrapLView(lView[tNode.index]);
-        return componentLView[RENDERER];
+    function loadComponentRenderer(currentDef, tNode, lView) {
+        // TODO(FW-2043): the `currentDef` is null when host bindings are invoked while creating root
+        // component (see packages/core/src/render3/component.ts). This is not consistent with the process
+        // of creating inner components, when current directive index is available in the state. In order
+        // to avoid relying on current def being `null` (thus special-casing root component creation), the
+        // process of creating root component should be unified with the process of creating inner
+        // components.
+        if (currentDef === null || isComponentDef(currentDef)) {
+            lView = unwrapLView(lView[tNode.index]);
+        }
+        return lView[RENDERER];
     }
     /** Handles an error thrown in an LView. */
     function handleError(lView, error) {
@@ -9372,17 +9491,13 @@
         ngDevMode && assertLContainer(insertedLContainer);
         var insertedComponentLView = insertedLContainer[PARENT][DECLARATION_COMPONENT_VIEW];
         ngDevMode && assertDefined(insertedComponentLView, 'Missing insertedComponentLView');
-        var insertedComponentIsOnPush = (insertedComponentLView[FLAGS] & 16 /* CheckAlways */) !== 16 /* CheckAlways */;
-        if (insertedComponentIsOnPush) {
-            var declaredComponentLView = lView[DECLARATION_COMPONENT_VIEW];
-            ngDevMode && assertDefined(declaredComponentLView, 'Missing declaredComponentLView');
-            if (declaredComponentLView !== insertedComponentLView) {
-                // At this point the declaration-component is not same as insertion-component and we are in
-                // on-push mode, 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 */;
-            }
+        var declaredComponentLView = lView[DECLARATION_COMPONENT_VIEW];
+        ngDevMode && assertDefined(declaredComponentLView, 'Missing declaredComponentLView');
+        if (declaredComponentLView !== insertedComponentLView) {
+            // 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 */;
         }
         if (movedViews === null) {
             declarationContainer[MOVED_VIEWS] = [lView];
@@ -9396,8 +9511,16 @@
         ngDevMode &&
             assertDefined(declarationContainer[MOVED_VIEWS], 'A projected view should belong to a non-empty projected views collection');
         var movedViews = declarationContainer[MOVED_VIEWS];
-        var declaredViewIndex = movedViews.indexOf(lView);
-        movedViews.splice(declaredViewIndex, 1);
+        var declarationViewIndex = movedViews.indexOf(lView);
+        var insertionLContainer = lView[PARENT];
+        ngDevMode && assertLContainer(insertionLContainer);
+        // If the view was marked for refresh but then detached before it was checked (where the flag
+        // would be cleared and the counter decremented), we need to decrement the view counter here
+        // instead.
+        if (lView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+            updateTransplantedViewCount(insertionLContainer, -1);
+        }
+        movedViews.splice(declarationViewIndex, 1);
     }
     /**
      * Detaches a view from a container.
@@ -10464,10 +10587,18 @@
             else if (tNodeType === 1 /* Projection */) {
                 var componentView = lView[DECLARATION_COMPONENT_VIEW];
                 var componentHost = componentView[T_HOST];
-                var parentView = getLViewParent(componentView);
-                var firstProjectedNode = componentHost.projection[tNode.projection];
-                if (firstProjectedNode !== null && parentView !== null) {
-                    collectNativeNodes(parentView[TVIEW], parentView, firstProjectedNode, result, true);
+                var slotIdx = tNode.projection;
+                ngDevMode &&
+                    assertDefined(componentHost.projection, 'Components with projection nodes (<ng-content>) must have projection slots defined.');
+                var nodesInSlot = componentHost.projection[slotIdx];
+                if (Array.isArray(nodesInSlot)) {
+                    result.push.apply(result, __spread(nodesInSlot));
+                }
+                else {
+                    var parentView = getLViewParent(componentView);
+                    ngDevMode &&
+                        assertDefined(parentView, 'Component views should always have a parent view (component\'s host view)');
+                    collectNativeNodes(parentView[TVIEW], parentView, nodesInSlot, result, true);
                 }
             }
             tNode = isProjection ? tNode.projectionNext : tNode.next;
@@ -14316,26 +14447,6 @@
      * 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
      */
-    /**
-     * Creates an LContainer for inline views, e.g.
-     *
-     * % if (showing) {
-     *   <div></div>
-     * % }
-     *
-     * @param index The index of the container in the data array
-     *
-     * @codeGenApi
-     */
-    function ɵɵcontainer(index) {
-        var lView = getLView();
-        var tView = getTView();
-        var tNode = containerInternal(tView, lView, index, null, null);
-        if (tView.firstCreatePass) {
-            tNode.tViews = [];
-        }
-        setIsNotParent();
-    }
     function templateFirstCreatePass(index, tView, lView, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex) {
         ngDevMode && assertFirstCreatePass(tView);
         ngDevMode && ngDevMode.firstCreatePass++;
@@ -14392,83 +14503,6 @@
             saveResolvedLocalsInData(lView, tNode, localRefExtractor);
         }
     }
-    /**
-     * Sets a container up to receive views.
-     *
-     * @param index The index of the container in the data array
-     *
-     * @codeGenApi
-     */
-    function ɵɵcontainerRefreshStart(index) {
-        var lView = getLView();
-        var tView = getTView();
-        var previousOrParentTNode = load(tView.data, index);
-        ngDevMode && assertNodeType(previousOrParentTNode, 0 /* Container */);
-        setPreviousOrParentTNode(previousOrParentTNode, true);
-        lView[index + HEADER_OFFSET][ACTIVE_INDEX] = 0;
-        // We need to execute init hooks here so ngOnInit hooks are called in top level views
-        // before they are called in embedded views (for backwards compatibility).
-        if (!getCheckNoChangesMode()) {
-            var hooksInitPhaseCompleted = (lView[FLAGS] & 3 /* InitPhaseStateMask */) === 3 /* InitPhaseCompleted */;
-            if (hooksInitPhaseCompleted) {
-                var preOrderCheckHooks = tView.preOrderCheckHooks;
-                if (preOrderCheckHooks !== null) {
-                    executeCheckHooks(lView, preOrderCheckHooks, null);
-                }
-            }
-            else {
-                var preOrderHooks = tView.preOrderHooks;
-                if (preOrderHooks !== null) {
-                    executeInitAndCheckHooks(lView, preOrderHooks, 0 /* OnInitHooksToBeRun */, null);
-                }
-                incrementInitPhaseFlags(lView, 0 /* OnInitHooksToBeRun */);
-            }
-        }
-    }
-    /**
-     * Marks the end of the LContainer.
-     *
-     * Marking the end of LContainer is the time when to child views get inserted or removed.
-     *
-     * @codeGenApi
-     */
-    function ɵɵcontainerRefreshEnd() {
-        var previousOrParentTNode = getPreviousOrParentTNode();
-        if (getIsParent()) {
-            setIsNotParent();
-        }
-        else {
-            ngDevMode && assertNodeType(previousOrParentTNode, 2 /* View */);
-            ngDevMode && assertHasParent(previousOrParentTNode);
-            previousOrParentTNode = previousOrParentTNode.parent;
-            setPreviousOrParentTNode(previousOrParentTNode, false);
-        }
-        ngDevMode && assertNodeType(previousOrParentTNode, 0 /* Container */);
-        var lContainer = getLView()[previousOrParentTNode.index];
-        var nextIndex = getLContainerActiveIndex(lContainer);
-        // remove extra views at the end of the container
-        while (nextIndex < lContainer.length - CONTAINER_HEADER_OFFSET) {
-            removeView(lContainer, nextIndex);
-        }
-    }
-    function containerInternal(tView, lView, nodeIndex, tagName, attrs) {
-        ngDevMode &&
-            assertEqual(getBindingIndex(), tView.bindingStartIndex, 'container nodes should be created before any bindings');
-        var adjustedIndex = nodeIndex + HEADER_OFFSET;
-        ngDevMode && assertDataInRange(lView, nodeIndex + HEADER_OFFSET);
-        ngDevMode && ngDevMode.rendererCreateComment++;
-        var comment = lView[adjustedIndex] =
-            lView[RENDERER].createComment(ngDevMode ? 'container' : '');
-        var tNode = getOrCreateTNode(tView, lView[T_HOST], nodeIndex, 0 /* Container */, tagName, attrs);
-        var lContainer = lView[adjustedIndex] = createLContainer(comment, lView, comment, tNode);
-        appendChild(tView, lView, comment, tNode);
-        attachPatchData(comment, lView);
-        // Containers are added to the current view tree instead of their embedded views
-        // because views can be removed and re-inserted.
-        addToViewTree(lView, lContainer);
-        ngDevMode && assertNodeType(getPreviousOrParentTNode(), 0 /* Container */);
-        return tNode;
-    }
 
     /**
      * @license
@@ -14855,124 +14889,6 @@
         ɵɵelementContainerEnd();
     }
 
-    /**
-     * @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
-     */
-    /**
-     * Marks the start of an embedded view.
-     *
-     * @param viewBlockId The ID of this view
-     * @return boolean Whether or not this view is in creation mode
-     *
-     * @codeGenApi
-     */
-    function ɵɵembeddedViewStart(viewBlockId, decls, vars) {
-        var lView = getLView();
-        var previousOrParentTNode = getPreviousOrParentTNode();
-        // The previous node can be a view node if we are processing an inline for loop
-        var containerTNode = previousOrParentTNode.type === 2 /* View */ ?
-            previousOrParentTNode.parent :
-            previousOrParentTNode;
-        var lContainer = lView[containerTNode.index];
-        ngDevMode && assertNodeType(containerTNode, 0 /* Container */);
-        var viewToRender = scanForView(lContainer, getLContainerActiveIndex(lContainer), viewBlockId);
-        if (viewToRender) {
-            setIsParent();
-            enterView(viewToRender, viewToRender[TVIEW].node);
-        }
-        else {
-            // When we create a new LView, we always reset the state of the instructions.
-            viewToRender = createLView(lView, getOrCreateEmbeddedTView(viewBlockId, decls, vars, containerTNode), null, 16 /* CheckAlways */, null, null);
-            var tParentNode = getIsParent() ? previousOrParentTNode :
-                previousOrParentTNode && previousOrParentTNode.parent;
-            assignTViewNodeToLView(viewToRender[TVIEW], tParentNode, viewBlockId, viewToRender);
-            enterView(viewToRender, viewToRender[TVIEW].node);
-        }
-        if (lContainer) {
-            if (isCreationMode(viewToRender)) {
-                // it is a new view, insert it into collection of views for a given container
-                insertView(viewToRender[TVIEW], viewToRender, lContainer, getLContainerActiveIndex(lContainer));
-            }
-            lContainer[ACTIVE_INDEX] += 2 /* INCREMENT */;
-        }
-        return isCreationMode(viewToRender) ? 1 /* Create */ | 2 /* Update */ :
-            2 /* Update */;
-    }
-    /**
-     * Initialize the TView (e.g. static data) for the active embedded view.
-     *
-     * Each embedded view block must create or retrieve its own TView. Otherwise, the embedded view's
-     * static data for a particular node would overwrite the static data for a node in the view above
-     * it with the same index (since it's in the same template).
-     *
-     * @param viewIndex The index of the TView in TNode.tViews
-     * @param decls The number of nodes, local refs, and pipes in this template
-     * @param vars The number of bindings and pure function bindings in this template
-     * @param container The parent container in which to look for the view's static data
-     * @returns TView
-     */
-    function getOrCreateEmbeddedTView(viewIndex, decls, vars, parent) {
-        var tView = getLView()[TVIEW];
-        ngDevMode && assertNodeType(parent, 0 /* Container */);
-        var containerTViews = parent.tViews;
-        ngDevMode && assertDefined(containerTViews, 'TView expected');
-        ngDevMode && assertEqual(Array.isArray(containerTViews), true, 'TViews should be in an array');
-        if (viewIndex >= containerTViews.length || containerTViews[viewIndex] == null) {
-            containerTViews[viewIndex] = createTView(2 /* Embedded */, viewIndex, null, decls, vars, tView.directiveRegistry, tView.pipeRegistry, null, null, tView.consts);
-        }
-        return containerTViews[viewIndex];
-    }
-    /**
-     * Looks for a view with a given view block id inside a provided LContainer.
-     * Removes views that need to be deleted in the process.
-     *
-     * @param lContainer to search for views
-     * @param startIdx starting index in the views array to search from
-     * @param viewBlockId exact view block id to look for
-     */
-    function scanForView(lContainer, startIdx, viewBlockId) {
-        for (var i = startIdx + CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
-            var viewAtPositionId = lContainer[i][TVIEW].id;
-            if (viewAtPositionId === viewBlockId) {
-                return lContainer[i];
-            }
-            else if (viewAtPositionId < viewBlockId) {
-                // found a view that should not be at this position - remove
-                removeView(lContainer, i - CONTAINER_HEADER_OFFSET);
-            }
-            else {
-                // found a view with id greater than the one we are searching for
-                // which means that required view doesn't exist and can't be found at
-                // later positions in the views array - stop the searchdef.cont here
-                break;
-            }
-        }
-        return null;
-    }
-    /**
-     * Marks the end of an embedded view.
-     *
-     * @codeGenApi
-     */
-    function ɵɵembeddedViewEnd() {
-        var lView = getLView();
-        var tView = getTView();
-        var viewHost = lView[T_HOST];
-        var context = lView[CONTEXT];
-        if (isCreationMode(lView)) {
-            renderView(tView, lView, context); // creation mode pass
-        }
-        refreshView(tView, lView, tView.template, context); // update mode pass
-        var lContainer = lView[PARENT];
-        ngDevMode && assertLContainerOrUndefined(lContainer);
-        leaveView();
-        setPreviousOrParentTNode(viewHost, false);
-    }
-
     /**
      * Returns the current OpaqueViewState instance.
      *
@@ -15040,7 +14956,7 @@
         return ɵɵlistener;
     }
     /**
-     * Registers a synthetic host listener (e.g. `(@foo.start)`) on a component.
+     * Registers a synthetic host listener (e.g. `(@foo.start)`) on a component or directive.
      *
      * This instruction is for compatibility purposes and is designed to ensure that a
      * synthetic host listener (e.g. `@HostListener('@foo.start')`) properly gets rendered
@@ -15064,8 +14980,9 @@
         if (useCapture === void 0) { useCapture = false; }
         var tNode = getPreviousOrParentTNode();
         var lView = getLView();
-        var renderer = loadComponentRenderer(tNode, lView);
         var tView = getTView();
+        var currentDef = getCurrentDirectiveDef(tView.data);
+        var renderer = loadComponentRenderer(currentDef, tNode, lView);
         listenerInternal(tView, lView, renderer, tNode, eventName, listenerFn, useCapture, eventTargetResolver);
         return ɵɵcomponentHostSyntheticListener;
     }
@@ -16841,7 +16758,7 @@
      * @param isClassBased `true` if `class` (`false` if `style`)
      */
     function wrapInStaticStylingKey(tData, tNode, stylingKey, isClassBased) {
-        var hostDirectiveDef = getHostDirectiveDef(tData);
+        var hostDirectiveDef = getCurrentDirectiveDef(tData);
         var residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;
         if (hostDirectiveDef === null) {
             // We are in template node.
@@ -17070,16 +16987,6 @@
         }
         return stylingKey === undefined ? null : stylingKey;
     }
-    /**
-     * Retrieve the current `DirectiveDef` which is active when `hostBindings` style instruction is
-     * being executed (or `null` if we are in `template`.)
-     *
-     * @param tData Current `TData` where the `DirectiveDef` will be looked up at.
-     */
-    function getHostDirectiveDef(tData) {
-        var currentDirectiveIndex = getCurrentDirectiveIndex();
-        return currentDirectiveIndex === -1 ? null : tData[currentDirectiveIndex];
-    }
     /**
      * Convert user input to `KeyValueArray`.
      *
@@ -18717,7 +18624,7 @@
         return ɵɵhostProperty;
     }
     /**
-     * Updates a synthetic host binding (e.g. `[@foo]`) on a component.
+     * Updates a synthetic host binding (e.g. `[@foo]`) on a component or directive.
      *
      * This instruction is for compatibility purposes and is designed to ensure that a
      * synthetic host binding (e.g. `@HostBinding('@foo')`) properly gets rendered in
@@ -18743,7 +18650,8 @@
         if (bindingUpdated(lView, bindingIndex, value)) {
             var tView = getTView();
             var tNode = getSelectedTNode();
-            var renderer = loadComponentRenderer(tNode, lView);
+            var currentDef = getCurrentDirectiveDef(tView.data);
+            var renderer = loadComponentRenderer(currentDef, tNode, lView);
             elementPropertyInternal(tView, tNode, lView, propName, value, renderer, sanitizer, true);
             ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
         }
@@ -20319,7 +20227,7 @@
     /**
      * @publicApi
      */
-    var VERSION = new Version('9.1.3');
+    var VERSION = new Version('9.1.7');
 
     /**
      * @license
@@ -23419,14 +23327,18 @@
                         }
                     }
                 }
-                tElementNode = getTNode(rootLView[TVIEW], 0);
-                if (projectableNodes) {
-                    // projectable nodes can be passed as array of arrays or an array of iterables (ngUpgrade
-                    // case). Here we do normalize passed data structure to be an array of arrays to avoid
-                    // complex checks down the line.
-                    tElementNode.projection = projectableNodes.map(function (nodesforSlot) {
-                        return Array.from(nodesforSlot);
-                    });
+                tElementNode = getTNode(rootTView, 0);
+                if (projectableNodes !== undefined) {
+                    var projection = tElementNode.projection = [];
+                    for (var i = 0; i < this.ngContentSelectors.length; i++) {
+                        var nodesforSlot = projectableNodes[i];
+                        // Projectable nodes can be passed as array of arrays or an array of iterables (ngUpgrade
+                        // case). Here we do normalize passed data structure to be an array of arrays to avoid
+                        // complex checks down the line.
+                        // We also normalize the length of the passed in projectable nodes (to match the number of
+                        // <ng-container> slots defined by a component).
+                        projection.push(nodesforSlot != null ? Array.from(nodesforSlot) : null);
+                    }
                 }
                 // TODO: should LifecycleHooksFeature and other host features be generated by the compiler and
                 // executed here?
@@ -23709,25 +23621,14 @@
      * 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
      */
+    var pluralMapping = ['zero', 'one', 'two', 'few', 'many'];
     /**
      * Returns the plural case based on the locale
      */
     function getPluralCase(value, locale) {
-        var plural = getLocalePluralCase(locale)(value);
-        switch (plural) {
-            case 0:
-                return 'zero';
-            case 1:
-                return 'one';
-            case 2:
-                return 'two';
-            case 3:
-                return 'few';
-            case 4:
-                return 'many';
-            default:
-                return 'other';
-        }
+        var plural = getLocalePluralCase(locale)(parseInt(value, 10));
+        var result = pluralMapping[plural];
+        return (result !== undefined) ? result : 'other';
     }
     /**
      * The locale id that the application is using by default (for translations and ICU expressions).
@@ -26558,10 +26459,7 @@
         'ɵɵProvidersFeature': ɵɵProvidersFeature,
         'ɵɵCopyDefinitionFeature': ɵɵCopyDefinitionFeature,
         'ɵɵInheritDefinitionFeature': ɵɵInheritDefinitionFeature,
-        'ɵɵcontainer': ɵɵcontainer,
         'ɵɵnextContext': ɵɵnextContext,
-        'ɵɵcontainerRefreshStart': ɵɵcontainerRefreshStart,
-        'ɵɵcontainerRefreshEnd': ɵɵcontainerRefreshEnd,
         'ɵɵnamespaceHTML': ɵɵnamespaceHTML,
         'ɵɵnamespaceMathML': ɵɵnamespaceMathML,
         'ɵɵnamespaceSVG': ɵɵnamespaceSVG,
@@ -26661,8 +26559,6 @@
         'ɵɵtextInterpolate7': ɵɵtextInterpolate7,
         'ɵɵtextInterpolate8': ɵɵtextInterpolate8,
         'ɵɵtextInterpolateV': ɵɵtextInterpolateV,
-        'ɵɵembeddedViewStart': ɵɵembeddedViewStart,
-        'ɵɵembeddedViewEnd': ɵɵembeddedViewEnd,
         'ɵɵi18n': ɵɵi18n,
         'ɵɵi18nAttributes': ɵɵi18nAttributes,
         'ɵɵi18nExp': ɵɵi18nExp,
@@ -33210,9 +33106,6 @@
     exports.ɵɵclassMapInterpolateV = ɵɵclassMapInterpolateV;
     exports.ɵɵclassProp = ɵɵclassProp;
     exports.ɵɵcomponentHostSyntheticListener = ɵɵcomponentHostSyntheticListener;
-    exports.ɵɵcontainer = ɵɵcontainer;
-    exports.ɵɵcontainerRefreshEnd = ɵɵcontainerRefreshEnd;
-    exports.ɵɵcontainerRefreshStart = ɵɵcontainerRefreshStart;
     exports.ɵɵcontentQuery = ɵɵcontentQuery;
     exports.ɵɵdefaultStyleSanitizer = ɵɵdefaultStyleSanitizer;
     exports.ɵɵdefineComponent = ɵɵdefineComponent;
@@ -33229,8 +33122,6 @@
     exports.ɵɵelementContainerStart = ɵɵelementContainerStart;
     exports.ɵɵelementEnd = ɵɵelementEnd;
     exports.ɵɵelementStart = ɵɵelementStart;
-    exports.ɵɵembeddedViewEnd = ɵɵembeddedViewEnd;
-    exports.ɵɵembeddedViewStart = ɵɵembeddedViewStart;
     exports.ɵɵenableBindings = ɵɵenableBindings;
     exports.ɵɵgetCurrentView = ɵɵgetCurrentView;
     exports.ɵɵgetFactoryOf = ɵɵgetFactoryOf;