@angular/core 13.0.0-next.8 → 13.0.0-rc.2

package/esm2020/src/render3/instructions/shared.mjs

@@ -0,0 +1,1811 @@
+import { ErrorHandler } from '../../error_handler';
+import { CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA } from '../../metadata/schema';
+import { ViewEncapsulation } from '../../metadata/view';
+import { validateAgainstEventAttributes, validateAgainstEventProperties } from '../../sanitization/sanitization';
+import { assertDefined, assertDomNode, assertEqual, assertGreaterThanOrEqual, assertIndexInRange, assertNotEqual, assertNotSame, assertSame, assertString } from '../../util/assert';
+import { escapeCommentText } from '../../util/dom';
+import { createNamedArrayType } from '../../util/named_array_type';
+import { initNgDevMode } from '../../util/ng_dev_mode';
+import { normalizeDebugBindingName, normalizeDebugBindingValue } from '../../util/ng_reflect';
+import { stringify } from '../../util/stringify';
+import { assertFirstCreatePass, assertFirstUpdatePass, assertLContainer, assertLView, assertTNodeForLView, assertTNodeForTView } from '../assert';
+import { attachPatchData, readPatchedLView } from '../context_discovery';
+import { getFactoryDef } from '../definition_factory';
+import { diPublicInInjector, getNodeInjectable, getOrCreateNodeInjectorForNode } from '../di';
+import { formatRuntimeError, RuntimeError } from '../error_code';
+import { throwMultipleComponentError } from '../errors';
+import { executeCheckHooks, executeInitAndCheckHooks, incrementInitPhaseFlags } from '../hooks';
+import { CONTAINER_HEADER_OFFSET, HAS_TRANSPLANTED_VIEWS, MOVED_VIEWS } from '../interfaces/container';
+import { NodeInjectorFactory } from '../interfaces/injector';
+import { isProceduralRenderer } from '../interfaces/renderer';
+import { isComponentDef, isComponentHost, isContentQueryHost, isRootView } from '../interfaces/type_checks';
+import { CHILD_HEAD, CHILD_TAIL, CLEANUP, CONTEXT, DECLARATION_COMPONENT_VIEW, DECLARATION_VIEW, FLAGS, HEADER_OFFSET, HOST, INJECTOR, NEXT, PARENT, RENDERER, RENDERER_FACTORY, SANITIZER, T_HOST, TRANSPLANTED_VIEWS_TO_REFRESH, TVIEW } from '../interfaces/view';
+import { assertPureTNodeType, assertTNodeType } from '../node_assert';
+import { updateTextNode } from '../node_manipulation';
+import { isInlineTemplate, isNodeMatchingSelectorList } from '../node_selector_matcher';
+import { profiler } from '../profiler';
+import { enterView, getBindingsEnabled, getCurrentDirectiveIndex, getCurrentParentTNode, getCurrentTNode, getCurrentTNodePlaceholderOk, getSelectedIndex, isCurrentTNodeParent, isInCheckNoChangesMode, isInI18nBlock, leaveView, setBindingIndex, setBindingRootForHostBindings, setCurrentDirectiveIndex, setCurrentQueryIndex, setCurrentTNode, setIsInCheckNoChangesMode, setSelectedIndex } from '../state';
+import { NO_CHANGE } from '../tokens';
+import { isAnimationProp, mergeHostAttrs } from '../util/attrs_utils';
+import { INTERPOLATION_DELIMITER } from '../util/misc_utils';
+import { renderStringify, stringifyForError } from '../util/stringify_utils';
+import { getFirstLContainer, getLViewParent, getNextLContainer } from '../util/view_traversal_utils';
+import { getComponentLViewByIndex, getNativeByIndex, getNativeByTNode, isCreationMode, resetPreOrderHookFlags, unwrapLView, updateTransplantedViewCount, viewAttachedToChangeDetector } from '../util/view_utils';
+import { selectIndexInternal } from './advance';
+import { attachLContainerDebug, attachLViewDebug, cloneToLViewFromTViewBlueprint, cloneToTViewData, LCleanup, LViewBlueprint, MatchesArray, TCleanup, TNodeDebug, TNodeInitialInputs, TNodeLocalNames, TViewComponents, TViewConstructor } from './lview_debug';
+/**
+ * A permanent marker promise which signifies that the current CD tree is
+ * clean.
+ */
+const _CLEAN_PROMISE = (() => Promise.resolve(null))();
+/**
+ * Invoke `HostBindingsFunction`s for view.
+ *
+ * This methods executes `TView.hostBindingOpCodes`. It is used to execute the
+ * `HostBindingsFunction`s associated with the current `LView`.
+ *
+ * @param tView Current `TView`.
+ * @param lView Current `LView`.
+ */
+export function processHostBindingOpCodes(tView, lView) {
+    const hostBindingOpCodes = tView.hostBindingOpCodes;
+    if (hostBindingOpCodes === null)
+        return;
+    try {
+        for (let i = 0; i < hostBindingOpCodes.length; i++) {
+            const opCode = hostBindingOpCodes[i];
+            if (opCode < 0) {
+                // Negative numbers are element indexes.
+                setSelectedIndex(~opCode);
+            }
+            else {
+                // Positive numbers are NumberTuple which store bindingRootIndex and directiveIndex.
+                const directiveIdx = opCode;
+                const bindingRootIndx = hostBindingOpCodes[++i];
+                const hostBindingFn = hostBindingOpCodes[++i];
+                setBindingRootForHostBindings(bindingRootIndx, directiveIdx);
+                const context = lView[directiveIdx];
+                hostBindingFn(2 /* Update */, context);
+            }
+        }
+    }
+    finally {
+        setSelectedIndex(-1);
+    }
+}
+/** Refreshes all content queries declared by directives in a given view */
+function refreshContentQueries(tView, lView) {
+    const contentQueries = tView.contentQueries;
+    if (contentQueries !== null) {
+        for (let i = 0; i < contentQueries.length; i += 2) {
+            const queryStartIdx = contentQueries[i];
+            const directiveDefIdx = contentQueries[i + 1];
+            if (directiveDefIdx !== -1) {
+                const directiveDef = tView.data[directiveDefIdx];
+                ngDevMode && assertDefined(directiveDef, 'DirectiveDef not found.');
+                ngDevMode &&
+                    assertDefined(directiveDef.contentQueries, 'contentQueries function should be defined');
+                setCurrentQueryIndex(queryStartIdx);
+                directiveDef.contentQueries(2 /* Update */, lView[directiveDefIdx], directiveDefIdx);
+            }
+        }
+    }
+}
+/** Refreshes child components in the current view (update mode). */
+function refreshChildComponents(hostLView, components) {
+    for (let i = 0; i < components.length; i++) {
+        refreshComponent(hostLView, components[i]);
+    }
+}
+/** Renders child components in the current view (creation mode). */
+function renderChildComponents(hostLView, components) {
+    for (let i = 0; i < components.length; i++) {
+        renderComponent(hostLView, components[i]);
+    }
+}
+export function createLView(parentLView, tView, context, flags, host, tHostNode, rendererFactory, renderer, sanitizer, injector) {
+    const lView = ngDevMode ? cloneToLViewFromTViewBlueprint(tView) : tView.blueprint.slice();
+    lView[HOST] = host;
+    lView[FLAGS] = flags | 4 /* CreationMode */ | 128 /* Attached */ | 8 /* FirstLViewPass */;
+    resetPreOrderHookFlags(lView);
+    ngDevMode && tView.declTNode && parentLView && assertTNodeForLView(tView.declTNode, parentLView);
+    lView[PARENT] = lView[DECLARATION_VIEW] = parentLView;
+    lView[CONTEXT] = context;
+    lView[RENDERER_FACTORY] = (rendererFactory || parentLView && parentLView[RENDERER_FACTORY]);
+    ngDevMode && assertDefined(lView[RENDERER_FACTORY], 'RendererFactory is required');
+    lView[RENDERER] = (renderer || parentLView && parentLView[RENDERER]);
+    ngDevMode && assertDefined(lView[RENDERER], 'Renderer is required');
+    lView[SANITIZER] = sanitizer || parentLView && parentLView[SANITIZER] || null;
+    lView[INJECTOR] = injector || parentLView && parentLView[INJECTOR] || null;
+    lView[T_HOST] = tHostNode;
+    ngDevMode &&
+        assertEqual(tView.type == 2 /* Embedded */ ? parentLView !== null : true, true, 'Embedded views must have parentLView');
+    lView[DECLARATION_COMPONENT_VIEW] =
+        tView.type == 2 /* Embedded */ ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
+    ngDevMode && attachLViewDebug(lView);
+    return lView;
+}
+export function getOrCreateTNode(tView, index, type, name, attrs) {
+    ngDevMode && index !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
+        // `view_engine_compatibility` for additional context.
+        assertGreaterThanOrEqual(index, HEADER_OFFSET, 'TNodes can\'t be in the LView header.');
+    // Keep this function short, so that the VM will inline it.
+    ngDevMode && assertPureTNodeType(type);
+    let tNode = tView.data[index];
+    if (tNode === null) {
+        tNode = createTNodeAtIndex(tView, index, type, name, attrs);
+        if (isInI18nBlock()) {
+            // If we are in i18n block then all elements should be pre declared through `Placeholder`
+            // See `TNodeType.Placeholder` and `LFrame.inI18n` for more context.
+            // If the `TNode` was not pre-declared than it means it was not mentioned which means it was
+            // removed, so we mark it as detached.
+            tNode.flags |= 64 /* isDetached */;
+        }
+    }
+    else if (tNode.type & 64 /* Placeholder */) {
+        tNode.type = type;
+        tNode.value = name;
+        tNode.attrs = attrs;
+        const parent = getCurrentParentTNode();
+        tNode.injectorIndex = parent === null ? -1 : parent.injectorIndex;
+        ngDevMode && assertTNodeForTView(tNode, tView);
+        ngDevMode && assertEqual(index, tNode.index, 'Expecting same index');
+    }
+    setCurrentTNode(tNode, true);
+    return tNode;
+}
+export function createTNodeAtIndex(tView, index, type, name, attrs) {
+    const currentTNode = getCurrentTNodePlaceholderOk();
+    const isParent = isCurrentTNodeParent();
+    const parent = isParent ? currentTNode : currentTNode && currentTNode.parent;
+    // Parents cannot cross component boundaries because components will be used in multiple places.
+    const tNode = tView.data[index] =
+        createTNode(tView, parent, type, index, name, attrs);
+    // Assign a pointer to the first child node of a given view. The first node is not always the one
+    // at index 0, in case of i18n, index 0 can be the instruction `i18nStart` and the first node has
+    // the index 1 or more, so we can't just check node index.
+    if (tView.firstChild === null) {
+        tView.firstChild = tNode;
+    }
+    if (currentTNode !== null) {
+        if (isParent) {
+            // FIXME(misko): This logic looks unnecessarily complicated. Could we simplify?
+            if (currentTNode.child == null && tNode.parent !== null) {
+                // We are in the same view, which means we are adding content node to the parent view.
+                currentTNode.child = tNode;
+            }
+        }
+        else {
+            if (currentTNode.next === null) {
+                // In the case of i18n the `currentTNode` may already be linked, in which case we don't want
+                // to break the links which i18n created.
+                currentTNode.next = tNode;
+            }
+        }
+    }
+    return tNode;
+}
+/**
+ * When elements are created dynamically after a view blueprint is created (e.g. through
+ * i18nApply()), we need to adjust the blueprint for future
+ * template passes.
+ *
+ * @param tView `TView` associated with `LView`
+ * @param lView The `LView` containing the blueprint to adjust
+ * @param numSlotsToAlloc The number of slots to alloc in the LView, should be >0
+ * @param initialValue Initial value to store in blueprint
+ */
+export function allocExpando(tView, lView, numSlotsToAlloc, initialValue) {
+    if (numSlotsToAlloc === 0)
+        return -1;
+    if (ngDevMode) {
+        assertFirstCreatePass(tView);
+        assertSame(tView, lView[TVIEW], '`LView` must be associated with `TView`!');
+        assertEqual(tView.data.length, lView.length, 'Expecting LView to be same size as TView');
+        assertEqual(tView.data.length, tView.blueprint.length, 'Expecting Blueprint to be same size as TView');
+        assertFirstUpdatePass(tView);
+    }
+    const allocIdx = lView.length;
+    for (let i = 0; i < numSlotsToAlloc; i++) {
+        lView.push(initialValue);
+        tView.blueprint.push(initialValue);
+        tView.data.push(null);
+    }
+    return allocIdx;
+}
+//////////////////////////
+//// Render
+//////////////////////////
+/**
+ * Processes a view in the creation mode. This includes a number of steps in a specific order:
+ * - creating view query functions (if any);
+ * - executing a template function in the creation mode;
+ * - updating static queries (if any);
+ * - creating child components defined in a given view.
+ */
+export function renderView(tView, lView, context) {
+    ngDevMode && assertEqual(isCreationMode(lView), true, 'Should be run in creation mode');
+    enterView(lView);
+    try {
+        const viewQuery = tView.viewQuery;
+        if (viewQuery !== null) {
+            executeViewQueryFn(1 /* Create */, viewQuery, context);
+        }
+        // Execute a template associated with this view, if it exists. A template function might not be
+        // defined for the root component views.
+        const templateFn = tView.template;
+        if (templateFn !== null) {
+            executeTemplate(tView, lView, templateFn, 1 /* Create */, context);
+        }
+        // This needs to be set before children are processed to support recursive components.
+        // This must be set to false immediately after the first creation run because in an
+        // ngFor loop, all the views will be created together before update mode runs and turns
+        // off firstCreatePass. If we don't set it here, instances will perform directive
+        // matching, etc again and again.
+        if (tView.firstCreatePass) {
+            tView.firstCreatePass = false;
+        }
+        // We resolve content queries specifically marked as `static` in creation mode. Dynamic
+        // content queries are resolved during change detection (i.e. update mode), after embedded
+        // views are refreshed (see block above).
+        if (tView.staticContentQueries) {
+            refreshContentQueries(tView, lView);
+        }
+        // We must materialize query results before child components are processed
+        // in case a child component has projected a container. The LContainer needs
+        // to exist so the embedded views are properly attached by the container.
+        if (tView.staticViewQueries) {
+            executeViewQueryFn(2 /* Update */, tView.viewQuery, context);
+        }
+        // Render child component views.
+        const components = tView.components;
+        if (components !== null) {
+            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;
+            tView.firstCreatePass = false;
+        }
+        throw error;
+    }
+    finally {
+        lView[FLAGS] &= ~4 /* CreationMode */;
+        leaveView();
+    }
+}
+/**
+ * Processes a view in update mode. This includes a number of steps in a specific order:
+ * - executing a template function in update mode;
+ * - executing hooks;
+ * - refreshing queries;
+ * - setting host bindings;
+ * - refreshing child (embedded and component) views.
+ */
+export function refreshView(tView, lView, templateFn, context) {
+    ngDevMode && assertEqual(isCreationMode(lView), false, 'Should be run in update mode');
+    const flags = lView[FLAGS];
+    if ((flags & 256 /* Destroyed */) === 256 /* Destroyed */)
+        return;
+    enterView(lView);
+    // Check no changes mode is a dev only mode used to verify that bindings have not changed
+    // since they were assigned. We do not want to execute lifecycle hooks in that mode.
+    const isInCheckNoChangesPass = isInCheckNoChangesMode();
+    try {
+        resetPreOrderHookFlags(lView);
+        setBindingIndex(tView.bindingStartIndex);
+        if (templateFn !== null) {
+            executeTemplate(tView, lView, templateFn, 2 /* Update */, context);
+        }
+        const hooksInitPhaseCompleted = (flags & 3 /* InitPhaseStateMask */) === 3 /* InitPhaseCompleted */;
+        // execute pre-order hooks (OnInit, OnChanges, DoCheck)
+        // PERF WARNING: do NOT extract this to a separate function without running benchmarks
+        if (!isInCheckNoChangesPass) {
+            if (hooksInitPhaseCompleted) {
+                const preOrderCheckHooks = tView.preOrderCheckHooks;
+                if (preOrderCheckHooks !== null) {
+                    executeCheckHooks(lView, preOrderCheckHooks, null);
+                }
+            }
+            else {
+                const preOrderHooks = tView.preOrderHooks;
+                if (preOrderHooks !== null) {
+                    executeInitAndCheckHooks(lView, preOrderHooks, 0 /* OnInitHooksToBeRun */, null);
+                }
+                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);
+        refreshEmbeddedViews(lView);
+        // Content query results must be refreshed before content hooks are called.
+        if (tView.contentQueries !== null) {
+            refreshContentQueries(tView, lView);
+        }
+        // execute content hooks (AfterContentInit, AfterContentChecked)
+        // PERF WARNING: do NOT extract this to a separate function without running benchmarks
+        if (!isInCheckNoChangesPass) {
+            if (hooksInitPhaseCompleted) {
+                const contentCheckHooks = tView.contentCheckHooks;
+                if (contentCheckHooks !== null) {
+                    executeCheckHooks(lView, contentCheckHooks);
+                }
+            }
+            else {
+                const contentHooks = tView.contentHooks;
+                if (contentHooks !== null) {
+                    executeInitAndCheckHooks(lView, contentHooks, 1 /* AfterContentInitHooksToBeRun */);
+                }
+                incrementInitPhaseFlags(lView, 1 /* AfterContentInitHooksToBeRun */);
+            }
+        }
+        processHostBindingOpCodes(tView, lView);
+        // Refresh child component views.
+        const components = tView.components;
+        if (components !== null) {
+            refreshChildComponents(lView, components);
+        }
+        // View queries must execute after refreshing child components because a template in this view
+        // could be inserted in a child component. If the view query executes before child component
+        // refresh, the template might not yet be inserted.
+        const viewQuery = tView.viewQuery;
+        if (viewQuery !== null) {
+            executeViewQueryFn(2 /* Update */, viewQuery, context);
+        }
+        // execute view hooks (AfterViewInit, AfterViewChecked)
+        // PERF WARNING: do NOT extract this to a separate function without running benchmarks
+        if (!isInCheckNoChangesPass) {
+            if (hooksInitPhaseCompleted) {
+                const viewCheckHooks = tView.viewCheckHooks;
+                if (viewCheckHooks !== null) {
+                    executeCheckHooks(lView, viewCheckHooks);
+                }
+            }
+            else {
+                const viewHooks = tView.viewHooks;
+                if (viewHooks !== null) {
+                    executeInitAndCheckHooks(lView, viewHooks, 2 /* AfterViewInitHooksToBeRun */);
+                }
+                incrementInitPhaseFlags(lView, 2 /* AfterViewInitHooksToBeRun */);
+            }
+        }
+        if (tView.firstUpdatePass === true) {
+            // We need to make sure that we only flip the flag on successful `refreshView` only
+            // Don't do this in `finally` block.
+            // If we did this in `finally` block then an exception could block the execution of styling
+            // instructions which in turn would be unable to insert themselves into the styling linked
+            // list. The result of this would be that if the exception would not be throw on subsequent CD
+            // the styling would be unable to process it data and reflect to the DOM.
+            tView.firstUpdatePass = false;
+        }
+        // Do not reset the dirty state when running in check no changes mode. We don't want components
+        // to behave differently depending on whether check no changes is enabled or not. For example:
+        // Marking an OnPush component as dirty from within the `ngAfterViewInit` hook in order to
+        // refresh a `NgClass` binding should work. If we would reset the dirty state in the check
+        // no changes cycle, the component would be not be dirty for the next update pass. This would
+        // be different in production mode where the component dirty state is not reset.
+        if (!isInCheckNoChangesPass) {
+            lView[FLAGS] &= ~(64 /* Dirty */ | 8 /* FirstLViewPass */);
+        }
+        if (lView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+            lView[FLAGS] &= ~1024 /* RefreshTransplantedView */;
+            updateTransplantedViewCount(lView[PARENT], -1);
+        }
+    }
+    finally {
+        leaveView();
+    }
+}
+export function renderComponentOrTemplate(tView, lView, templateFn, context) {
+    const rendererFactory = lView[RENDERER_FACTORY];
+    const normalExecutionPath = !isInCheckNoChangesMode();
+    const creationModeIsActive = isCreationMode(lView);
+    try {
+        if (normalExecutionPath && !creationModeIsActive && rendererFactory.begin) {
+            rendererFactory.begin();
+        }
+        if (creationModeIsActive) {
+            renderView(tView, lView, context);
+        }
+        refreshView(tView, lView, templateFn, context);
+    }
+    finally {
+        if (normalExecutionPath && !creationModeIsActive && rendererFactory.end) {
+            rendererFactory.end();
+        }
+    }
+}
+function executeTemplate(tView, lView, templateFn, rf, context) {
+    const prevSelectedIndex = getSelectedIndex();
+    const isUpdatePhase = rf & 2 /* Update */;
+    try {
+        setSelectedIndex(-1);
+        if (isUpdatePhase && lView.length > HEADER_OFFSET) {
+            // When we're updating, inherently select 0 so we don't
+            // have to generate that instruction for most update blocks.
+            selectIndexInternal(tView, lView, HEADER_OFFSET, isInCheckNoChangesMode());
+        }
+        const preHookType = isUpdatePhase ? 2 /* TemplateUpdateStart */ : 0 /* TemplateCreateStart */;
+        profiler(preHookType, context);
+        templateFn(rf, context);
+    }
+    finally {
+        setSelectedIndex(prevSelectedIndex);
+        const postHookType = isUpdatePhase ? 3 /* TemplateUpdateEnd */ : 1 /* TemplateCreateEnd */;
+        profiler(postHookType, context);
+    }
+}
+//////////////////////////
+//// Element
+//////////////////////////
+export function executeContentQueries(tView, tNode, lView) {
+    if (isContentQueryHost(tNode)) {
+        const start = tNode.directiveStart;
+        const end = tNode.directiveEnd;
+        for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
+            const def = tView.data[directiveIndex];
+            if (def.contentQueries) {
+                def.contentQueries(1 /* Create */, lView[directiveIndex], directiveIndex);
+            }
+        }
+    }
+}
+/**
+ * Creates directive instances.
+ */
+export function createDirectivesInstances(tView, lView, tNode) {
+    if (!getBindingsEnabled())
+        return;
+    instantiateAllDirectives(tView, lView, tNode, getNativeByTNode(tNode, lView));
+    if ((tNode.flags & 128 /* hasHostBindings */) === 128 /* hasHostBindings */) {
+        invokeDirectivesHostBindings(tView, lView, tNode);
+    }
+}
+/**
+ * Takes a list of local names and indices and pushes the resolved local variable values
+ * to LView in the same order as they are loaded in the template with load().
+ */
+export function saveResolvedLocalsInData(viewData, tNode, localRefExtractor = getNativeByTNode) {
+    const localNames = tNode.localNames;
+    if (localNames !== null) {
+        let localIndex = tNode.index + 1;
+        for (let i = 0; i < localNames.length; i += 2) {
+            const index = localNames[i + 1];
+            const value = index === -1 ?
+                localRefExtractor(tNode, viewData) :
+                viewData[index];
+            viewData[localIndex++] = value;
+        }
+    }
+}
+/**
+ * Gets TView from a template function or creates a new TView
+ * if it doesn't already exist.
+ *
+ * @param def ComponentDef
+ * @returns TView
+ */
+export function getOrCreateTComponentView(def) {
+    const tView = def.tView;
+    // Create a TView if there isn't one, or recreate it if the first create pass didn't
+    // complete successfully since we can't know for sure whether it's in a usable shape.
+    if (tView === null || tView.incompleteFirstPass) {
+        // Declaration node here is null since this function is called when we dynamically create a
+        // component and hence there is no declaration.
+        const declTNode = null;
+        return def.tView = createTView(1 /* Component */, declTNode, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts);
+    }
+    return tView;
+}
+/**
+ * Creates a TView instance
+ *
+ * @param type Type of `TView`.
+ * @param declTNode Declaration location of this `TView`.
+ * @param templateFn Template function
+ * @param decls The number of nodes, local refs, and pipes in this template
+ * @param directives Registry of directives for this view
+ * @param pipes Registry of pipes for this view
+ * @param viewQuery View queries for this view
+ * @param schemas Schemas for this view
+ * @param consts Constants for this view
+ */
+export function createTView(type, declTNode, templateFn, decls, vars, directives, pipes, viewQuery, schemas, constsOrFactory) {
+    ngDevMode && ngDevMode.tView++;
+    const bindingStartIndex = HEADER_OFFSET + decls;
+    // This length does not yet contain host bindings from child directives because at this point,
+    // we don't know which directives are active on this template. As soon as a directive is matched
+    // that has a host binding, we will update the blueprint with that def's hostVars count.
+    const initialViewLength = bindingStartIndex + vars;
+    const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);
+    const consts = typeof constsOrFactory === 'function' ? constsOrFactory() : constsOrFactory;
+    const tView = blueprint[TVIEW] = ngDevMode ?
+        new TViewConstructor(type, // type: TViewType,
+        blueprint, // blueprint: LView,
+        templateFn, // template: ComponentTemplate<{}>|null,
+        null, // queries: TQueries|null
+        viewQuery, // viewQuery: ViewQueriesFunction<{}>|null,
+        declTNode, // declTNode: TNode|null,
+        cloneToTViewData(blueprint).fill(null, bindingStartIndex), // data: TData,
+        bindingStartIndex, // bindingStartIndex: number,
+        initialViewLength, // expandoStartIndex: number,
+        null, // hostBindingOpCodes: HostBindingOpCodes,
+        true, // firstCreatePass: boolean,
+        true, // firstUpdatePass: boolean,
+        false, // staticViewQueries: boolean,
+        false, // staticContentQueries: boolean,
+        null, // preOrderHooks: HookData|null,
+        null, // preOrderCheckHooks: HookData|null,
+        null, // contentHooks: HookData|null,
+        null, // contentCheckHooks: HookData|null,
+        null, // viewHooks: HookData|null,
+        null, // viewCheckHooks: HookData|null,
+        null, // destroyHooks: DestroyHookData|null,
+        null, // cleanup: any[]|null,
+        null, // contentQueries: number[]|null,
+        null, // components: number[]|null,
+        typeof directives === 'function' ? //
+            directives() : //
+            directives, // directiveRegistry: DirectiveDefList|null,
+        typeof pipes === 'function' ? pipes() : pipes, // pipeRegistry: PipeDefList|null,
+        null, // firstChild: TNode|null,
+        schemas, // schemas: SchemaMetadata[]|null,
+        consts, // consts: TConstants|null
+        false, // incompleteFirstPass: boolean
+        decls, // ngDevMode only: decls
+        vars) :
+        {
+            type: type,
+            blueprint: blueprint,
+            template: templateFn,
+            queries: null,
+            viewQuery: viewQuery,
+            declTNode: declTNode,
+            data: blueprint.slice().fill(null, bindingStartIndex),
+            bindingStartIndex: bindingStartIndex,
+            expandoStartIndex: initialViewLength,
+            hostBindingOpCodes: null,
+            firstCreatePass: true,
+            firstUpdatePass: true,
+            staticViewQueries: false,
+            staticContentQueries: false,
+            preOrderHooks: null,
+            preOrderCheckHooks: null,
+            contentHooks: null,
+            contentCheckHooks: null,
+            viewHooks: null,
+            viewCheckHooks: null,
+            destroyHooks: null,
+            cleanup: null,
+            contentQueries: null,
+            components: null,
+            directiveRegistry: typeof directives === 'function' ? directives() : directives,
+            pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
+            firstChild: null,
+            schemas: schemas,
+            consts: consts,
+            incompleteFirstPass: false
+        };
+    if (ngDevMode) {
+        // For performance reasons it is important that the tView retains the same shape during runtime.
+        // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
+        // prevent class transitions.
+        Object.seal(tView);
+    }
+    return tView;
+}
+function createViewBlueprint(bindingStartIndex, initialViewLength) {
+    const blueprint = ngDevMode ? new LViewBlueprint() : [];
+    for (let i = 0; i < initialViewLength; i++) {
+        blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);
+    }
+    return blueprint;
+}
+function createError(text, token) {
+    return new Error(`Renderer: ${text} [${stringifyForError(token)}]`);
+}
+function assertHostNodeExists(rElement, elementOrSelector) {
+    if (!rElement) {
+        if (typeof elementOrSelector === 'string') {
+            throw createError('Host node with selector not found:', elementOrSelector);
+        }
+        else {
+            throw createError('Host node is required:', elementOrSelector);
+        }
+    }
+}
+/**
+ * Locates the host native element, used for bootstrapping existing nodes into rendering pipeline.
+ *
+ * @param rendererFactory Factory function to create renderer instance.
+ * @param elementOrSelector Render element or CSS selector to locate the element.
+ * @param encapsulation View Encapsulation defined for component that requests host element.
+ */
+export function locateHostElement(renderer, elementOrSelector, encapsulation) {
+    if (isProceduralRenderer(renderer)) {
+        // When using native Shadow DOM, do not clear host element to allow native slot projection
+        const preserveContent = encapsulation === ViewEncapsulation.ShadowDom;
+        return renderer.selectRootElement(elementOrSelector, preserveContent);
+    }
+    let rElement = typeof elementOrSelector === 'string' ?
+        renderer.querySelector(elementOrSelector) :
+        elementOrSelector;
+    ngDevMode && assertHostNodeExists(rElement, elementOrSelector);
+    // Always clear host element's content when Renderer3 is in use. For procedural renderer case we
+    // make it depend on whether ShadowDom encapsulation is used (in which case the content should be
+    // preserved to allow native slot projection). ShadowDom encapsulation requires procedural
+    // renderer, and procedural renderer case is handled above.
+    rElement.textContent = '';
+    return rElement;
+}
+/**
+ * Saves context for this cleanup function in LView.cleanupInstances.
+ *
+ * On the first template pass, saves in TView:
+ * - Cleanup function
+ * - Index of context we just saved in LView.cleanupInstances
+ *
+ * This function can also be used to store instance specific cleanup fns. In that case the `context`
+ * is `null` and the function is store in `LView` (rather than it `TView`).
+ */
+export function storeCleanupWithContext(tView, lView, context, cleanupFn) {
+    const lCleanup = getOrCreateLViewCleanup(lView);
+    if (context === null) {
+        // If context is null that this is instance specific callback. These callbacks can only be
+        // inserted after template shared instances. For this reason in ngDevMode we freeze the TView.
+        if (ngDevMode) {
+            Object.freeze(getOrCreateTViewCleanup(tView));
+        }
+        lCleanup.push(cleanupFn);
+    }
+    else {
+        lCleanup.push(context);
+        if (tView.firstCreatePass) {
+            getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
+        }
+    }
+}
+export function createTNode(tView, tParent, type, index, value, attrs) {
+    ngDevMode && index !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
+        // `view_engine_compatibility` for additional context.
+        assertGreaterThanOrEqual(index, HEADER_OFFSET, 'TNodes can\'t be in the LView header.');
+    ngDevMode && assertNotSame(attrs, undefined, '\'undefined\' is not valid value for \'attrs\'');
+    ngDevMode && ngDevMode.tNode++;
+    ngDevMode && tParent && assertTNodeForTView(tParent, tView);
+    let injectorIndex = tParent ? tParent.injectorIndex : -1;
+    const tNode = ngDevMode ?
+        new TNodeDebug(tView, // tView_: TView
+        type, // type: TNodeType
+        index, // index: number
+        null, // insertBeforeIndex: null|-1|number|number[]
+        injectorIndex, // injectorIndex: number
+        -1, // directiveStart: number
+        -1, // directiveEnd: number
+        -1, // directiveStylingLast: number
+        null, // propertyBindings: number[]|null
+        0, // flags: TNodeFlags
+        0, // providerIndexes: TNodeProviderIndexes
+        value, // value: string|null
+        attrs, // attrs: (string|AttributeMarker|(string|SelectorFlags)[])[]|null
+        null, // mergedAttrs
+        null, // localNames: (string|number)[]|null
+        undefined, // initialInputs: (string[]|null)[]|null|undefined
+        null, // inputs: PropertyAliases|null
+        null, // outputs: PropertyAliases|null
+        null, // tViews: ITView|ITView[]|null
+        null, // next: ITNode|null
+        null, // projectionNext: ITNode|null
+        null, // child: ITNode|null
+        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, // residualClasses: string|null
+        0, // classBindings: TStylingRange;
+        0) :
+        {
+            type,
+            index,
+            insertBeforeIndex: null,
+            injectorIndex,
+            directiveStart: -1,
+            directiveEnd: -1,
+            directiveStylingLast: -1,
+            propertyBindings: null,
+            flags: 0,
+            providerIndexes: 0,
+            value: value,
+            attrs: attrs,
+            mergedAttrs: null,
+            localNames: null,
+            initialInputs: undefined,
+            inputs: null,
+            outputs: null,
+            tViews: null,
+            next: null,
+            projectionNext: null,
+            child: null,
+            parent: tParent,
+            projection: null,
+            styles: null,
+            stylesWithoutHost: null,
+            residualStyles: undefined,
+            classes: null,
+            classesWithoutHost: null,
+            residualClasses: undefined,
+            classBindings: 0,
+            styleBindings: 0,
+        };
+    if (ngDevMode) {
+        // For performance reasons it is important that the tNode retains the same shape during runtime.
+        // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
+        // prevent class transitions.
+        Object.seal(tNode);
+    }
+    return tNode;
+}
+function generatePropertyAliases(inputAliasMap, directiveDefIdx, propStore) {
+    for (let publicName in inputAliasMap) {
+        if (inputAliasMap.hasOwnProperty(publicName)) {
+            propStore = propStore === null ? {} : propStore;
+            const internalName = inputAliasMap[publicName];
+            if (propStore.hasOwnProperty(publicName)) {
+                propStore[publicName].push(directiveDefIdx, internalName);
+            }
+            else {
+                (propStore[publicName] = [directiveDefIdx, internalName]);
+            }
+        }
+    }
+    return propStore;
+}
+/**
+ * Initializes data structures required to work with directive inputs and outputs.
+ * Initialization is done for all directives matched on a given TNode.
+ */
+function initializeInputAndOutputAliases(tView, tNode) {
+    ngDevMode && assertFirstCreatePass(tView);
+    const start = tNode.directiveStart;
+    const end = tNode.directiveEnd;
+    const tViewData = tView.data;
+    const tNodeAttrs = tNode.attrs;
+    const inputsFromAttrs = ngDevMode ? new TNodeInitialInputs() : [];
+    let inputsStore = null;
+    let outputsStore = null;
+    for (let i = start; i < end; i++) {
+        const directiveDef = tViewData[i];
+        const directiveInputs = directiveDef.inputs;
+        // Do not use unbound attributes as inputs to structural directives, since structural
+        // directive inputs can only be set using microsyntax (e.g. `<div *dir="exp">`).
+        // TODO(FW-1930): microsyntax expressions may also contain unbound/static attributes, which
+        // should be set for inline templates.
+        const initialInputs = (tNodeAttrs !== null && !isInlineTemplate(tNode)) ?
+            generateInitialInputs(directiveInputs, tNodeAttrs) :
+            null;
+        inputsFromAttrs.push(initialInputs);
+        inputsStore = generatePropertyAliases(directiveInputs, i, inputsStore);
+        outputsStore = generatePropertyAliases(directiveDef.outputs, i, outputsStore);
+    }
+    if (inputsStore !== null) {
+        if (inputsStore.hasOwnProperty('class')) {
+            tNode.flags |= 16 /* hasClassInput */;
+        }
+        if (inputsStore.hasOwnProperty('style')) {
+            tNode.flags |= 32 /* hasStyleInput */;
+        }
+    }
+    tNode.initialInputs = inputsFromAttrs;
+    tNode.inputs = inputsStore;
+    tNode.outputs = outputsStore;
+}
+/**
+ * Mapping between attributes names that don't correspond to their element property names.
+ *
+ * Performance note: this function is written as a series of if checks (instead of, say, a property
+ * object lookup) for performance reasons - the series of `if` checks seems to be the fastest way of
+ * mapping property names. Do NOT change without benchmarking.
+ *
+ * Note: this mapping has to be kept in sync with the equally named mapping in the template
+ * type-checking machinery of ngtsc.
+ */
+function mapPropName(name) {
+    if (name === 'class')
+        return 'className';
+    if (name === 'for')
+        return 'htmlFor';
+    if (name === 'formaction')
+        return 'formAction';
+    if (name === 'innerHtml')
+        return 'innerHTML';
+    if (name === 'readonly')
+        return 'readOnly';
+    if (name === 'tabindex')
+        return 'tabIndex';
+    return name;
+}
+export function elementPropertyInternal(tView, tNode, lView, propName, value, renderer, sanitizer, nativeOnly) {
+    ngDevMode && assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
+    const element = getNativeByTNode(tNode, lView);
+    let inputData = tNode.inputs;
+    let dataValue;
+    if (!nativeOnly && inputData != null && (dataValue = inputData[propName])) {
+        setInputsForProperty(tView, lView, dataValue, propName, value);
+        if (isComponentHost(tNode))
+            markDirtyIfOnPush(lView, tNode.index);
+        if (ngDevMode) {
+            setNgReflectProperties(lView, element, tNode.type, dataValue, value);
+        }
+    }
+    else if (tNode.type & 3 /* AnyRNode */) {
+        propName = mapPropName(propName);
+        if (ngDevMode) {
+            validateAgainstEventProperties(propName);
+            if (!validateProperty(tView, element, propName, tNode)) {
+                // Return here since we only log warnings for unknown properties.
+                logUnknownPropertyError(propName, tNode);
+                return;
+            }
+            ngDevMode.rendererSetProperty++;
+        }
+        // It is assumed that the sanitizer is only added when the compiler determines that the
+        // property is risky, so sanitization can be done without further checks.
+        value = sanitizer != null ? sanitizer(value, tNode.value || '', propName) : value;
+        if (isProceduralRenderer(renderer)) {
+            renderer.setProperty(element, propName, value);
+        }
+        else if (!isAnimationProp(propName)) {
+            element.setProperty ? element.setProperty(propName, value) :
+                element[propName] = value;
+        }
+    }
+    else if (tNode.type & 12 /* AnyContainer */) {
+        // If the node is a container and the property didn't
+        // match any of the inputs or schemas we should throw.
+        if (ngDevMode && !matchingSchemas(tView, tNode.value)) {
+            logUnknownPropertyError(propName, tNode);
+        }
+    }
+}
+/** If node is an OnPush component, marks its LView dirty. */
+function markDirtyIfOnPush(lView, viewIndex) {
+    ngDevMode && assertLView(lView);
+    const childComponentLView = getComponentLViewByIndex(viewIndex, lView);
+    if (!(childComponentLView[FLAGS] & 16 /* CheckAlways */)) {
+        childComponentLView[FLAGS] |= 64 /* Dirty */;
+    }
+}
+function setNgReflectProperty(lView, element, type, attrName, value) {
+    const renderer = lView[RENDERER];
+    attrName = normalizeDebugBindingName(attrName);
+    const debugValue = normalizeDebugBindingValue(value);
+    if (type & 3 /* AnyRNode */) {
+        if (value == null) {
+            isProceduralRenderer(renderer) ? renderer.removeAttribute(element, attrName) :
+                element.removeAttribute(attrName);
+        }
+        else {
+            isProceduralRenderer(renderer) ?
+                renderer.setAttribute(element, attrName, debugValue) :
+                element.setAttribute(attrName, debugValue);
+        }
+    }
+    else {
+        const textContent = escapeCommentText(`bindings=${JSON.stringify({ [attrName]: debugValue }, null, 2)}`);
+        if (isProceduralRenderer(renderer)) {
+            renderer.setValue(element, textContent);
+        }
+        else {
+            element.textContent = textContent;
+        }
+    }
+}
+export function setNgReflectProperties(lView, element, type, dataValue, value) {
+    if (type & (3 /* AnyRNode */ | 4 /* Container */)) {
+        /**
+         * dataValue is an array containing runtime input or output names for the directives:
+         * i+0: directive instance index
+         * i+1: privateName
+         *
+         * e.g. [0, 'change', 'change-minified']
+         * we want to set the reflected property with the privateName: dataValue[i+1]
+         */
+        for (let i = 0; i < dataValue.length; i += 2) {
+            setNgReflectProperty(lView, element, type, dataValue[i + 1], value);
+        }
+    }
+}
+function validateProperty(tView, element, propName, tNode) {
+    // If `schemas` is set to `null`, that's an indication that this Component was compiled in AOT
+    // mode where this check happens at compile time. In JIT mode, `schemas` is always present and
+    // defined as an array (as an empty array in case `schemas` field is not defined) and we should
+    // execute the check below.
+    if (tView.schemas === null)
+        return true;
+    // The property is considered valid if the element matches the schema, it exists on the element
+    // or it is synthetic, and we are in a browser context (web worker nodes should be skipped).
+    if (matchingSchemas(tView, tNode.value) || propName in element || isAnimationProp(propName)) {
+        return true;
+    }
+    // Note: `typeof Node` returns 'function' in most browsers, but on IE it is 'object' so we
+    // need to account for both here, while being careful for `typeof null` also returning 'object'.
+    return typeof Node === 'undefined' || Node === null || !(element instanceof Node);
+}
+export function matchingSchemas(tView, tagName) {
+    const schemas = tView.schemas;
+    if (schemas !== null) {
+        for (let i = 0; i < schemas.length; i++) {
+            const schema = schemas[i];
+            if (schema === NO_ERRORS_SCHEMA ||
+                schema === CUSTOM_ELEMENTS_SCHEMA && tagName && tagName.indexOf('-') > -1) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Logs an error that a property is not supported on an element.
+ * @param propName Name of the invalid property.
+ * @param tNode Node on which we encountered the property.
+ */
+function logUnknownPropertyError(propName, tNode) {
+    let message = `Can't bind to '${propName}' since it isn't a known property of '${tNode.value}'.`;
+    console.error(formatRuntimeError("303" /* UNKNOWN_BINDING */, message));
+}
+/**
+ * Instantiate a root component.
+ */
+export function instantiateRootComponent(tView, lView, def) {
+    const rootTNode = getCurrentTNode();
+    if (tView.firstCreatePass) {
+        if (def.providersResolver)
+            def.providersResolver(def);
+        const directiveIndex = allocExpando(tView, lView, 1, null);
+        ngDevMode &&
+            assertEqual(directiveIndex, rootTNode.directiveStart, 'Because this is a root component the allocated expando should match the TNode component.');
+        configureViewWithDirective(tView, rootTNode, lView, directiveIndex, def);
+    }
+    const directive = getNodeInjectable(lView, tView, rootTNode.directiveStart, rootTNode);
+    attachPatchData(directive, lView);
+    const native = getNativeByTNode(rootTNode, lView);
+    if (native) {
+        attachPatchData(native, lView);
+    }
+    return directive;
+}
+/**
+ * Resolve the matched directives on a node.
+ */
+export function resolveDirectives(tView, lView, tNode, localRefs) {
+    // Please make sure to have explicit type for `exportsMap`. Inferred type triggers bug in
+    // tsickle.
+    ngDevMode && assertFirstCreatePass(tView);
+    let hasDirectives = false;
+    if (getBindingsEnabled()) {
+        const directiveDefs = findDirectiveDefMatches(tView, lView, tNode);
+        const exportsMap = localRefs === null ? null : { '': -1 };
+        if (directiveDefs !== null) {
+            hasDirectives = true;
+            initTNodeFlags(tNode, tView.data.length, directiveDefs.length);
+            // When the same token is provided by several directives on the same node, some rules apply in
+            // the viewEngine:
+            // - viewProviders have priority over providers
+            // - the last directive in NgModule.declarations has priority over the previous one
+            // So to match these rules, the order in which providers are added in the arrays is very
+            // important.
+            for (let i = 0; i < directiveDefs.length; i++) {
+                const def = directiveDefs[i];
+                if (def.providersResolver)
+                    def.providersResolver(def);
+            }
+            let preOrderHooksFound = false;
+            let preOrderCheckHooksFound = false;
+            let directiveIdx = allocExpando(tView, lView, directiveDefs.length, null);
+            ngDevMode &&
+                assertSame(directiveIdx, tNode.directiveStart, 'TNode.directiveStart should point to just allocated space');
+            for (let i = 0; i < directiveDefs.length; i++) {
+                const def = directiveDefs[i];
+                // Merge the attrs in the order of matches. This assumes that the first directive is the
+                // component itself, so that the component has the least priority.
+                tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, def.hostAttrs);
+                configureViewWithDirective(tView, tNode, lView, directiveIdx, def);
+                saveNameToExportMap(directiveIdx, def, exportsMap);
+                if (def.contentQueries !== null)
+                    tNode.flags |= 8 /* hasContentQuery */;
+                if (def.hostBindings !== null || def.hostAttrs !== null || def.hostVars !== 0)
+                    tNode.flags |= 128 /* hasHostBindings */;
+                const lifeCycleHooks = def.type.prototype;
+                // Only push a node index into the preOrderHooks array if this is the first
+                // pre-order hook found on this node.
+                if (!preOrderHooksFound &&
+                    (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngOnInit || lifeCycleHooks.ngDoCheck)) {
+                    // We will push the actual hook function into this array later during dir instantiation.
+                    // We cannot do it now because we must ensure hooks are registered in the same
+                    // order that directives are created (i.e. injection order).
+                    (tView.preOrderHooks || (tView.preOrderHooks = [])).push(tNode.index);
+                    preOrderHooksFound = true;
+                }
+                if (!preOrderCheckHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngDoCheck)) {
+                    (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(tNode.index);
+                    preOrderCheckHooksFound = true;
+                }
+                directiveIdx++;
+            }
+            initializeInputAndOutputAliases(tView, tNode);
+        }
+        if (exportsMap)
+            cacheMatchingLocalNames(tNode, localRefs, exportsMap);
+    }
+    // Merge the template attrs last so that they have the highest priority.
+    tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
+    return hasDirectives;
+}
+/**
+ * Add `hostBindings` to the `TView.hostBindingOpCodes`.
+ *
+ * @param tView `TView` to which the `hostBindings` should be added.
+ * @param tNode `TNode` the element which contains the directive
+ * @param lView `LView` current `LView`
+ * @param directiveIdx Directive index in view.
+ * @param directiveVarsIdx Where will the directive's vars be stored
+ * @param def `ComponentDef`/`DirectiveDef`, which contains the `hostVars`/`hostBindings` to add.
+ */
+export function registerHostBindingOpCodes(tView, tNode, lView, directiveIdx, directiveVarsIdx, def) {
+    ngDevMode && assertFirstCreatePass(tView);
+    const hostBindings = def.hostBindings;
+    if (hostBindings) {
+        let hostBindingOpCodes = tView.hostBindingOpCodes;
+        if (hostBindingOpCodes === null) {
+            hostBindingOpCodes = tView.hostBindingOpCodes = [];
+        }
+        const elementIndx = ~tNode.index;
+        if (lastSelectedElementIdx(hostBindingOpCodes) != elementIndx) {
+            // Conditionally add select element so that we are more efficient in execution.
+            // NOTE: this is strictly not necessary and it trades code size for runtime perf.
+            // (We could just always add it.)
+            hostBindingOpCodes.push(elementIndx);
+        }
+        hostBindingOpCodes.push(directiveIdx, directiveVarsIdx, hostBindings);
+    }
+}
+/**
+ * Returns the last selected element index in the `HostBindingOpCodes`
+ *
+ * For perf reasons we don't need to update the selected element index in `HostBindingOpCodes` only
+ * if it changes. This method returns the last index (or '0' if not found.)
+ *
+ * Selected element index are only the ones which are negative.
+ */
+function lastSelectedElementIdx(hostBindingOpCodes) {
+    let i = hostBindingOpCodes.length;
+    while (i > 0) {
+        const value = hostBindingOpCodes[--i];
+        if (typeof value === 'number' && value < 0) {
+            return value;
+        }
+    }
+    return 0;
+}
+/**
+ * Instantiate all the directives that were previously resolved on the current node.
+ */
+function instantiateAllDirectives(tView, lView, tNode, native) {
+    const start = tNode.directiveStart;
+    const end = tNode.directiveEnd;
+    if (!tView.firstCreatePass) {
+        getOrCreateNodeInjectorForNode(tNode, lView);
+    }
+    attachPatchData(native, lView);
+    const initialInputs = tNode.initialInputs;
+    for (let i = start; i < end; i++) {
+        const def = tView.data[i];
+        const isComponent = isComponentDef(def);
+        if (isComponent) {
+            ngDevMode && assertTNodeType(tNode, 3 /* AnyRNode */);
+            addComponentLogic(lView, tNode, def);
+        }
+        const directive = getNodeInjectable(lView, tView, i, tNode);
+        attachPatchData(directive, lView);
+        if (initialInputs !== null) {
+            setInputsFromAttrs(lView, i - start, directive, def, tNode, initialInputs);
+        }
+        if (isComponent) {
+            const componentView = getComponentLViewByIndex(tNode.index, lView);
+            componentView[CONTEXT] = directive;
+        }
+    }
+}
+function invokeDirectivesHostBindings(tView, lView, tNode) {
+    const start = tNode.directiveStart;
+    const end = tNode.directiveEnd;
+    const firstCreatePass = tView.firstCreatePass;
+    const elementIndex = tNode.index;
+    const currentDirectiveIndex = getCurrentDirectiveIndex();
+    try {
+        setSelectedIndex(elementIndex);
+        for (let dirIndex = start; dirIndex < end; dirIndex++) {
+            const def = tView.data[dirIndex];
+            const directive = lView[dirIndex];
+            setCurrentDirectiveIndex(dirIndex);
+            if (def.hostBindings !== null || def.hostVars !== 0 || def.hostAttrs !== null) {
+                invokeHostBindingsInCreationMode(def, directive);
+            }
+        }
+    }
+    finally {
+        setSelectedIndex(-1);
+        setCurrentDirectiveIndex(currentDirectiveIndex);
+    }
+}
+/**
+ * Invoke the host bindings in creation mode.
+ *
+ * @param def `DirectiveDef` which may contain the `hostBindings` function.
+ * @param directive Instance of directive.
+ */
+export function invokeHostBindingsInCreationMode(def, directive) {
+    if (def.hostBindings !== null) {
+        def.hostBindings(1 /* Create */, directive);
+    }
+}
+/**
+ * Matches the current node against all available selectors.
+ * If a component is matched (at most one), it is returned in first position in the array.
+ */
+function findDirectiveDefMatches(tView, viewData, tNode) {
+    ngDevMode && assertFirstCreatePass(tView);
+    ngDevMode && assertTNodeType(tNode, 3 /* AnyRNode */ | 12 /* AnyContainer */);
+    const registry = tView.directiveRegistry;
+    let matches = null;
+    if (registry) {
+        for (let i = 0; i < registry.length; i++) {
+            const def = registry[i];
+            if (isNodeMatchingSelectorList(tNode, def.selectors, /* isProjectionMode */ false)) {
+                matches || (matches = ngDevMode ? new MatchesArray() : []);
+                diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, viewData), tView, def.type);
+                if (isComponentDef(def)) {
+                    if (ngDevMode) {
+                        assertTNodeType(tNode, 2 /* Element */, `"${tNode.value}" tags cannot be used as component hosts. ` +
+                            `Please use a different tag to activate the ${stringify(def.type)} component.`);
+                        if (tNode.flags & 2 /* isComponentHost */)
+                            throwMultipleComponentError(tNode);
+                    }
+                    markAsComponentHost(tView, tNode);
+                    // The component is always stored first with directives after.
+                    matches.unshift(def);
+                }
+                else {
+                    matches.push(def);
+                }
+            }
+        }
+    }
+    return matches;
+}
+/**
+ * Marks a given TNode as a component's host. This consists of:
+ * - setting appropriate TNode flags;
+ * - storing index of component's host element so it will be queued for view refresh during CD.
+ */
+export function markAsComponentHost(tView, hostTNode) {
+    ngDevMode && assertFirstCreatePass(tView);
+    hostTNode.flags |= 2 /* isComponentHost */;
+    (tView.components || (tView.components = ngDevMode ? new TViewComponents() : []))
+        .push(hostTNode.index);
+}
+/** Caches local names and their matching directive indices for query and template lookups. */
+function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
+    if (localRefs) {
+        const localNames = tNode.localNames = ngDevMode ? new TNodeLocalNames() : [];
+        // Local names must be stored in tNode in the same order that localRefs are defined
+        // in the template to ensure the data is loaded in the same slots as their refs
+        // in the template (for template queries).
+        for (let i = 0; i < localRefs.length; i += 2) {
+            const index = exportsMap[localRefs[i + 1]];
+            if (index == null)
+                throw new RuntimeError("301" /* EXPORT_NOT_FOUND */, `Export of name '${localRefs[i + 1]}' not found!`);
+            localNames.push(localRefs[i], index);
+        }
+    }
+}
+/**
+ * Builds up an export map as directives are created, so local refs can be quickly mapped
+ * to their directive instances.
+ */
+function saveNameToExportMap(directiveIdx, def, exportsMap) {
+    if (exportsMap) {
+        if (def.exportAs) {
+            for (let i = 0; i < def.exportAs.length; i++) {
+                exportsMap[def.exportAs[i]] = directiveIdx;
+            }
+        }
+        if (isComponentDef(def))
+            exportsMap[''] = directiveIdx;
+    }
+}
+/**
+ * Initializes the flags on the current node, setting all indices to the initial index,
+ * the directive count to 0, and adding the isComponent flag.
+ * @param index the initial index
+ */
+export function initTNodeFlags(tNode, index, numberOfDirectives) {
+    ngDevMode &&
+        assertNotEqual(numberOfDirectives, tNode.directiveEnd - tNode.directiveStart, 'Reached the max number of directives');
+    tNode.flags |= 1 /* isDirectiveHost */;
+    // When the first directive is created on a node, save the index
+    tNode.directiveStart = index;
+    tNode.directiveEnd = index + numberOfDirectives;
+    tNode.providerIndexes = index;
+}
+/**
+ * Setup directive for instantiation.
+ *
+ * We need to create a `NodeInjectorFactory` which is then inserted in both the `Blueprint` as well
+ * as `LView`. `TView` gets the `DirectiveDef`.
+ *
+ * @param tView `TView`
+ * @param tNode `TNode`
+ * @param lView `LView`
+ * @param directiveIndex Index where the directive will be stored in the Expando.
+ * @param def `DirectiveDef`
+ */
+function configureViewWithDirective(tView, tNode, lView, directiveIndex, def) {
+    ngDevMode &&
+        assertGreaterThanOrEqual(directiveIndex, HEADER_OFFSET, 'Must be in Expando section');
+    tView.data[directiveIndex] = def;
+    const directiveFactory = def.factory || (def.factory = getFactoryDef(def.type, true));
+    const nodeInjectorFactory = new NodeInjectorFactory(directiveFactory, isComponentDef(def), null);
+    tView.blueprint[directiveIndex] = nodeInjectorFactory;
+    lView[directiveIndex] = nodeInjectorFactory;
+    registerHostBindingOpCodes(tView, tNode, lView, directiveIndex, allocExpando(tView, lView, def.hostVars, NO_CHANGE), def);
+}
+function addComponentLogic(lView, hostTNode, def) {
+    const native = getNativeByTNode(hostTNode, lView);
+    const tView = getOrCreateTComponentView(def);
+    // Only component views should be added to the view tree directly. Embedded views are
+    // accessed through their containers because they may be removed / re-added later.
+    const rendererFactory = lView[RENDERER_FACTORY];
+    const componentView = addToViewTree(lView, createLView(lView, tView, null, def.onPush ? 64 /* Dirty */ : 16 /* CheckAlways */, native, hostTNode, rendererFactory, rendererFactory.createRenderer(native, def), null, null));
+    // Component view will always be created before any injected LContainers,
+    // so this is a regular element, wrap it with the component view
+    lView[hostTNode.index] = componentView;
+}
+export function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
+    if (ngDevMode) {
+        assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
+        validateAgainstEventAttributes(name);
+        assertTNodeType(tNode, 2 /* Element */, `Attempted to set attribute \`${name}\` on a container node. ` +
+            `Host bindings are not valid on ng-container or ng-template.`);
+    }
+    const element = getNativeByTNode(tNode, lView);
+    setElementAttribute(lView[RENDERER], element, namespace, tNode.value, name, value, sanitizer);
+}
+export function setElementAttribute(renderer, element, namespace, tagName, name, value, sanitizer) {
+    if (value == null) {
+        ngDevMode && ngDevMode.rendererRemoveAttribute++;
+        isProceduralRenderer(renderer) ? renderer.removeAttribute(element, name, namespace) :
+            element.removeAttribute(name);
+    }
+    else {
+        ngDevMode && ngDevMode.rendererSetAttribute++;
+        const strValue = sanitizer == null ? renderStringify(value) : sanitizer(value, tagName || '', name);
+        if (isProceduralRenderer(renderer)) {
+            renderer.setAttribute(element, name, strValue, namespace);
+        }
+        else {
+            namespace ? element.setAttributeNS(namespace, name, strValue) :
+                element.setAttribute(name, strValue);
+        }
+    }
+}
+/**
+ * Sets initial input properties on directive instances from attribute data
+ *
+ * @param lView Current LView that is being processed.
+ * @param directiveIndex Index of the directive in directives array
+ * @param instance Instance of the directive on which to set the initial inputs
+ * @param def The directive def that contains the list of inputs
+ * @param tNode The static data for this node
+ */
+function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initialInputData) {
+    const initialInputs = initialInputData[directiveIndex];
+    if (initialInputs !== null) {
+        const setInput = def.setInput;
+        for (let i = 0; i < initialInputs.length;) {
+            const publicName = initialInputs[i++];
+            const privateName = initialInputs[i++];
+            const value = initialInputs[i++];
+            if (setInput !== null) {
+                def.setInput(instance, value, publicName, privateName);
+            }
+            else {
+                instance[privateName] = value;
+            }
+            if (ngDevMode) {
+                const nativeElement = getNativeByTNode(tNode, lView);
+                setNgReflectProperty(lView, nativeElement, tNode.type, privateName, value);
+            }
+        }
+    }
+}
+/**
+ * Generates initialInputData for a node and stores it in the template's static storage
+ * so subsequent template invocations don't have to recalculate it.
+ *
+ * initialInputData is an array containing values that need to be set as input properties
+ * for directives on this node, but only once on creation. We need this array to support
+ * the case where you set an @Input property of a directive using attribute-like syntax.
+ * e.g. if you have a `name` @Input, you can set it once like this:
+ *
+ * <my-component name="Bess"></my-component>
+ *
+ * @param inputs The list of inputs from the directive def
+ * @param attrs The static attrs on this node
+ */
+function generateInitialInputs(inputs, attrs) {
+    let inputsToStore = null;
+    let i = 0;
+    while (i < attrs.length) {
+        const attrName = attrs[i];
+        if (attrName === 0 /* NamespaceURI */) {
+            // We do not allow inputs on namespaced attributes.
+            i += 4;
+            continue;
+        }
+        else if (attrName === 5 /* ProjectAs */) {
+            // Skip over the `ngProjectAs` value.
+            i += 2;
+            continue;
+        }
+        // If we hit any other attribute markers, we're done anyway. None of those are valid inputs.
+        if (typeof attrName === 'number')
+            break;
+        if (inputs.hasOwnProperty(attrName)) {
+            if (inputsToStore === null)
+                inputsToStore = [];
+            inputsToStore.push(attrName, inputs[attrName], attrs[i + 1]);
+        }
+        i += 2;
+    }
+    return inputsToStore;
+}
+//////////////////////////
+//// ViewContainer & View
+//////////////////////////
+// Not sure why I need to do `any` here but TS complains later.
+const LContainerArray = ((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode()) &&
+    createNamedArrayType('LContainer');
+/**
+ * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.
+ *
+ * @param hostNative The host element for the LContainer
+ * @param hostTNode The host TNode for the LContainer
+ * @param currentView The parent view of the LContainer
+ * @param native The native comment element
+ * @param isForViewContainerRef Optional a flag indicating the ViewContainerRef case
+ * @returns LContainer
+ */
+export function createLContainer(hostNative, currentView, native, tNode) {
+    ngDevMode && assertLView(currentView);
+    ngDevMode && !isProceduralRenderer(currentView[RENDERER]) && assertDomNode(native);
+    // https://jsperf.com/array-literal-vs-new-array-really
+    const lContainer = new (ngDevMode ? LContainerArray : Array)(hostNative, // host native
+    true, // Boolean `true` in this position signifies that this is an `LContainer`
+    false, // has transplanted views
+    currentView, // parent
+    null, // next
+    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;
+}
+/**
+ * Goes over embedded views (ones created through ViewContainerRef APIs) and refreshes
+ * them by executing an associated template function.
+ */
+function refreshEmbeddedViews(lView) {
+    for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+        for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+            const embeddedLView = lContainer[i];
+            const embeddedTView = embeddedLView[TVIEW];
+            ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');
+            if (viewAttachedToChangeDetector(embeddedLView)) {
+                refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]);
+            }
+        }
+    }
+}
+/**
+ * Mark transplanted views as needing to be refreshed at their insertion points.
+ *
+ * @param lView The `LView` that may have transplanted views.
+ */
+function markTransplantedViewsForRefresh(lView) {
+    for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+        if (!lContainer[HAS_TRANSPLANTED_VIEWS])
+            continue;
+        const movedViews = lContainer[MOVED_VIEWS];
+        ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
+        for (let i = 0; i < movedViews.length; i++) {
+            const movedLView = movedViews[i];
+            const 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
+            // `refreshEmbeddedViews` for the view currently being refreshed.
+            movedLView[FLAGS] |= 1024 /* RefreshTransplantedView */;
+        }
+    }
+}
+/////////////
+/**
+ * Refreshes components by entering the component view and processing its bindings, queries, etc.
+ *
+ * @param componentHostIdx  Element index in LView[] (adjusted for HEADER_OFFSET)
+ */
+function refreshComponent(hostLView, componentHostIdx) {
+    ngDevMode && assertEqual(isCreationMode(hostLView), false, 'Should be run in update mode');
+    const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
+    // Only attached components that are CheckAlways or OnPush and dirty should be refreshed
+    if (viewAttachedToChangeDetector(componentView)) {
+        const 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 (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+        for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+            const embeddedLView = lContainer[i];
+            if (embeddedLView[FLAGS] & 1024 /* RefreshTransplantedView */) {
+                const 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);
+            }
+        }
+    }
+    const tView = lView[TVIEW];
+    // Refresh child component views.
+    const components = tView.components;
+    if (components !== null) {
+        for (let i = 0; i < components.length; i++) {
+            const 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) {
+    ngDevMode && assertEqual(isCreationMode(hostLView), true, 'Should be run in creation mode');
+    const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
+    const componentTView = componentView[TVIEW];
+    syncViewWithBlueprint(componentTView, componentView);
+    renderView(componentTView, componentView, componentView[CONTEXT]);
+}
+/**
+ * Syncs an LView instance with its blueprint if they have gotten out of sync.
+ *
+ * Typically, blueprints and their view instances should always be in sync, so the loop here
+ * will be skipped. However, consider this case of two components side-by-side:
+ *
+ * App template:
+ * ```
+ * <comp></comp>
+ * <comp></comp>
+ * ```
+ *
+ * The following will happen:
+ * 1. App template begins processing.
+ * 2. First <comp> is matched as a component and its LView is created.
+ * 3. Second <comp> is matched as a component and its LView is created.
+ * 4. App template completes processing, so it's time to check child templates.
+ * 5. First <comp> template is checked. It has a directive, so its def is pushed to blueprint.
+ * 6. Second <comp> template is checked. Its blueprint has been updated by the first
+ * <comp> template, but its LView was created before this update, so it is out of sync.
+ *
+ * Note that embedded views inside ngFor loops will never be out of sync because these views
+ * are processed as soon as they are created.
+ *
+ * @param tView The `TView` that contains the blueprint for syncing
+ * @param lView The view to sync
+ */
+function syncViewWithBlueprint(tView, lView) {
+    for (let i = lView.length; i < tView.blueprint.length; i++) {
+        lView.push(tView.blueprint[i]);
+    }
+}
+/**
+ * Adds LView or LContainer to the end of the current view tree.
+ *
+ * This structure will be used to traverse through nested views to remove listeners
+ * and call onDestroy callbacks.
+ *
+ * @param lView The view where LView or LContainer should be added
+ * @param adjustedHostIndex Index of the view's host node in LView[], adjusted for header
+ * @param lViewOrLContainer The LView or LContainer to add to the view tree
+ * @returns The state passed in
+ */
+export function addToViewTree(lView, lViewOrLContainer) {
+    // TODO(benlesh/misko): This implementation is incorrect, because it always adds the LContainer
+    // to the end of the queue, which means if the developer retrieves the LContainers from RNodes out
+    // of order, the change detection will run out of order, as the act of retrieving the the
+    // LContainer from the RNode is what adds it to the queue.
+    if (lView[CHILD_HEAD]) {
+        lView[CHILD_TAIL][NEXT] = lViewOrLContainer;
+    }
+    else {
+        lView[CHILD_HEAD] = lViewOrLContainer;
+    }
+    lView[CHILD_TAIL] = lViewOrLContainer;
+    return lViewOrLContainer;
+}
+///////////////////////////////
+//// Change detection
+///////////////////////////////
+/**
+ * Marks current view and all ancestors dirty.
+ *
+ * Returns the root view because it is found as a byproduct of marking the view tree
+ * dirty, and can be used by methods that consume markViewDirty() to easily schedule
+ * change detection. Otherwise, such methods would need to traverse up the view tree
+ * an additional time to get the root view and schedule a tick on it.
+ *
+ * @param lView The starting LView to mark dirty
+ * @returns the root LView
+ */
+export function markViewDirty(lView) {
+    while (lView) {
+        lView[FLAGS] |= 64 /* Dirty */;
+        const parent = getLViewParent(lView);
+        // Stop traversing up as soon as you find a root view that wasn't attached to any container
+        if (isRootView(lView) && !parent) {
+            return lView;
+        }
+        // continue otherwise
+        lView = parent;
+    }
+    return null;
+}
+/**
+ * Used to schedule change detection on the whole application.
+ *
+ * Unlike `tick`, `scheduleTick` coalesces multiple calls into one change detection run.
+ * It is usually called indirectly by calling `markDirty` when the view needs to be
+ * re-rendered.
+ *
+ * Typically `scheduleTick` uses `requestAnimationFrame` to coalesce multiple
+ * `scheduleTick` requests. The scheduling function can be overridden in
+ * `renderComponent`'s `scheduler` option.
+ */
+export function scheduleTick(rootContext, flags) {
+    const nothingScheduled = rootContext.flags === 0 /* Empty */;
+    if (nothingScheduled && rootContext.clean == _CLEAN_PROMISE) {
+        // https://github.com/angular/angular/issues/39296
+        // should only attach the flags when really scheduling a tick
+        rootContext.flags |= flags;
+        let res;
+        rootContext.clean = new Promise((r) => res = r);
+        rootContext.scheduler(() => {
+            if (rootContext.flags & 1 /* DetectChanges */) {
+                rootContext.flags &= ~1 /* DetectChanges */;
+                tickRootContext(rootContext);
+            }
+            if (rootContext.flags & 2 /* FlushPlayers */) {
+                rootContext.flags &= ~2 /* FlushPlayers */;
+                const playerHandler = rootContext.playerHandler;
+                if (playerHandler) {
+                    playerHandler.flushPlayers();
+                }
+            }
+            rootContext.clean = _CLEAN_PROMISE;
+            res(null);
+        });
+    }
+}
+export function tickRootContext(rootContext) {
+    for (let i = 0; i < rootContext.components.length; i++) {
+        const rootComponent = rootContext.components[i];
+        const lView = readPatchedLView(rootComponent);
+        const tView = lView[TVIEW];
+        renderComponentOrTemplate(tView, lView, tView.template, rootComponent);
+    }
+}
+export function detectChangesInternal(tView, lView, context) {
+    const rendererFactory = lView[RENDERER_FACTORY];
+    if (rendererFactory.begin)
+        rendererFactory.begin();
+    try {
+        refreshView(tView, lView, tView.template, context);
+    }
+    catch (error) {
+        handleError(lView, error);
+        throw error;
+    }
+    finally {
+        if (rendererFactory.end)
+            rendererFactory.end();
+    }
+}
+/**
+ * Synchronously perform change detection on a root view and its components.
+ *
+ * @param lView The view which the change detection should be performed on.
+ */
+export function detectChangesInRootView(lView) {
+    tickRootContext(lView[CONTEXT]);
+}
+export function checkNoChangesInternal(tView, view, context) {
+    setIsInCheckNoChangesMode(true);
+    try {
+        detectChangesInternal(tView, view, context);
+    }
+    finally {
+        setIsInCheckNoChangesMode(false);
+    }
+}
+/**
+ * Checks the change detector on a root view and its components, and throws if any changes are
+ * detected.
+ *
+ * This is used in development mode to verify that running change detection doesn't
+ * introduce other changes.
+ *
+ * @param lView The view which the change detection should be checked on.
+ */
+export function checkNoChangesInRootView(lView) {
+    setIsInCheckNoChangesMode(true);
+    try {
+        detectChangesInRootView(lView);
+    }
+    finally {
+        setIsInCheckNoChangesMode(false);
+    }
+}
+function executeViewQueryFn(flags, viewQueryFn, component) {
+    ngDevMode && assertDefined(viewQueryFn, 'View queries function to execute must be defined.');
+    setCurrentQueryIndex(0);
+    viewQueryFn(flags, component);
+}
+///////////////////////////////
+//// Bindings & interpolations
+///////////////////////////////
+/**
+ * Stores meta-data for a property binding to be used by TestBed's `DebugElement.properties`.
+ *
+ * In order to support TestBed's `DebugElement.properties` we need to save, for each binding:
+ * - a bound property name;
+ * - a static parts of interpolated strings;
+ *
+ * A given property metadata is saved at the binding's index in the `TView.data` (in other words, a
+ * property binding metadata will be stored in `TView.data` at the same index as a bound value in
+ * `LView`). Metadata are represented as `INTERPOLATION_DELIMITER`-delimited string with the
+ * following format:
+ * - `propertyName` for bound properties;
+ * - `propertyName�prefix�interpolation_static_part1�..interpolation_static_partN�suffix` for
+ * interpolated properties.
+ *
+ * @param tData `TData` where meta-data will be saved;
+ * @param tNode `TNode` that is a target of the binding;
+ * @param propertyName bound property name;
+ * @param bindingIndex binding index in `LView`
+ * @param interpolationParts static interpolation parts (for property interpolations)
+ */
+export function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex, ...interpolationParts) {
+    // Binding meta-data are stored only the first time a given property instruction is processed.
+    // Since we don't have a concept of the "first update pass" we need to check for presence of the
+    // binding meta-data to decide if one should be stored (or if was stored already).
+    if (tData[bindingIndex] === null) {
+        if (tNode.inputs == null || !tNode.inputs[propertyName]) {
+            const propBindingIdxs = tNode.propertyBindings || (tNode.propertyBindings = []);
+            propBindingIdxs.push(bindingIndex);
+            let bindingMetadata = propertyName;
+            if (interpolationParts.length > 0) {
+                bindingMetadata +=
+                    INTERPOLATION_DELIMITER + interpolationParts.join(INTERPOLATION_DELIMITER);
+            }
+            tData[bindingIndex] = bindingMetadata;
+        }
+    }
+}
+export const CLEAN_PROMISE = _CLEAN_PROMISE;
+export function getOrCreateLViewCleanup(view) {
+    // top level variables should not be exported for performance reasons (PERF_NOTES.md)
+    return view[CLEANUP] || (view[CLEANUP] = ngDevMode ? new LCleanup() : []);
+}
+export function getOrCreateTViewCleanup(tView) {
+    return tView.cleanup || (tView.cleanup = ngDevMode ? new TCleanup() : []);
+}
+/**
+ * There are cases where the sub component's renderer needs to be included
+ * instead of the current renderer (see the componentSyntheticHost* instructions).
+ */
+export 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. */
+export function handleError(lView, error) {
+    const injector = lView[INJECTOR];
+    const errorHandler = injector ? injector.get(ErrorHandler, null) : null;
+    errorHandler && errorHandler.handleError(error);
+}
+/**
+ * Set the inputs of directives at the current node to corresponding value.
+ *
+ * @param tView The current TView
+ * @param lView the `LView` which contains the directives.
+ * @param inputs mapping between the public "input" name and privately-known,
+ *        possibly minified, property names to write to.
+ * @param value Value to set.
+ */
+export function setInputsForProperty(tView, lView, inputs, publicName, value) {
+    for (let i = 0; i < inputs.length;) {
+        const index = inputs[i++];
+        const privateName = inputs[i++];
+        const instance = lView[index];
+        ngDevMode && assertIndexInRange(lView, index);
+        const def = tView.data[index];
+        if (def.setInput !== null) {
+            def.setInput(instance, value, publicName, privateName);
+        }
+        else {
+            instance[privateName] = value;
+        }
+    }
+}
+/**
+ * Updates a text binding at a given index in a given LView.
+ */
+export function textBindingInternal(lView, index, value) {
+    ngDevMode && assertString(value, 'Value should be a string');
+    ngDevMode && assertNotSame(value, NO_CHANGE, 'value should not be NO_CHANGE');
+    ngDevMode && assertIndexInRange(lView, index);
+    const element = getNativeByIndex(index, lView);
+    ngDevMode && assertDefined(element, 'native element should exist');
+    updateTextNode(lView[RENDERER], element, value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/shared.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {Injector} from '../../di';\nimport {ErrorHandler} from '../../error_handler';\nimport {DoCheck, OnChanges, OnInit} from '../../interface/lifecycle_hooks';\nimport {CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, SchemaMetadata} from '../../metadata/schema';\nimport {ViewEncapsulation} from '../../metadata/view';\nimport {validateAgainstEventAttributes, validateAgainstEventProperties} from '../../sanitization/sanitization';\nimport {Sanitizer} from '../../sanitization/sanitizer';\nimport {assertDefined, assertDomNode, assertEqual, assertGreaterThanOrEqual, assertIndexInRange, assertNotEqual, assertNotSame, assertSame, assertString} from '../../util/assert';\nimport {escapeCommentText} from '../../util/dom';\nimport {createNamedArrayType} from '../../util/named_array_type';\nimport {initNgDevMode} from '../../util/ng_dev_mode';\nimport {normalizeDebugBindingName, normalizeDebugBindingValue} from '../../util/ng_reflect';\nimport {stringify} from '../../util/stringify';\nimport {assertFirstCreatePass, assertFirstUpdatePass, assertLContainer, assertLView, assertTNodeForLView, assertTNodeForTView} from '../assert';\nimport {attachPatchData, readPatchedLView} from '../context_discovery';\nimport {getFactoryDef} from '../definition_factory';\nimport {diPublicInInjector, getNodeInjectable, getOrCreateNodeInjectorForNode} from '../di';\nimport {formatRuntimeError, RuntimeError, RuntimeErrorCode} from '../error_code';\nimport {throwMultipleComponentError} from '../errors';\nimport {executeCheckHooks, executeInitAndCheckHooks, incrementInitPhaseFlags} from '../hooks';\nimport {CONTAINER_HEADER_OFFSET, HAS_TRANSPLANTED_VIEWS, LContainer, MOVED_VIEWS} from '../interfaces/container';\nimport {ComponentDef, ComponentTemplate, DirectiveDef, DirectiveDefListOrFactory, HostBindingsFunction, PipeDefListOrFactory, RenderFlags, ViewQueriesFunction} from '../interfaces/definition';\nimport {NodeInjectorFactory} from '../interfaces/injector';\nimport {AttributeMarker, InitialInputData, InitialInputs, LocalRefExtractor, PropertyAliases, PropertyAliasValue, TAttributes, TConstantsOrFactory, TContainerNode, TDirectiveHostNode, TElementContainerNode, TElementNode, TIcuContainerNode, TNode, TNodeFlags, TNodeType, TProjectionNode} from '../interfaces/node';\nimport {isProceduralRenderer, Renderer3, RendererFactory3} from '../interfaces/renderer';\nimport {RComment, RElement, RNode, RText} from '../interfaces/renderer_dom';\nimport {SanitizerFn} from '../interfaces/sanitization';\nimport {isComponentDef, isComponentHost, isContentQueryHost, isRootView} from '../interfaces/type_checks';\nimport {CHILD_HEAD, CHILD_TAIL, CLEANUP, CONTEXT, DECLARATION_COMPONENT_VIEW, DECLARATION_VIEW, FLAGS, HEADER_OFFSET, HOST, HostBindingOpCodes, InitPhaseState, INJECTOR, LView, LViewFlags, NEXT, PARENT, RENDERER, RENDERER_FACTORY, RootContext, RootContextFlags, SANITIZER, T_HOST, TData, TRANSPLANTED_VIEWS_TO_REFRESH, TVIEW, TView, TViewType} from '../interfaces/view';\nimport {assertPureTNodeType, assertTNodeType} from '../node_assert';\nimport {updateTextNode} from '../node_manipulation';\nimport {isInlineTemplate, isNodeMatchingSelectorList} from '../node_selector_matcher';\nimport {profiler, ProfilerEvent} from '../profiler';\nimport {enterView, getBindingsEnabled, getCurrentDirectiveIndex, getCurrentParentTNode, getCurrentTNode, getCurrentTNodePlaceholderOk, getSelectedIndex, isCurrentTNodeParent, isInCheckNoChangesMode, isInI18nBlock, leaveView, setBindingIndex, setBindingRootForHostBindings, setCurrentDirectiveIndex, setCurrentQueryIndex, setCurrentTNode, setIsInCheckNoChangesMode, setSelectedIndex} from '../state';\nimport {NO_CHANGE} from '../tokens';\nimport {isAnimationProp, mergeHostAttrs} from '../util/attrs_utils';\nimport {INTERPOLATION_DELIMITER} from '../util/misc_utils';\nimport {renderStringify, stringifyForError} from '../util/stringify_utils';\nimport {getFirstLContainer, getLViewParent, getNextLContainer} from '../util/view_traversal_utils';\nimport {getComponentLViewByIndex, getNativeByIndex, getNativeByTNode, isCreationMode, resetPreOrderHookFlags, unwrapLView, updateTransplantedViewCount, viewAttachedToChangeDetector} from '../util/view_utils';\n\nimport {selectIndexInternal} from './advance';\nimport {attachLContainerDebug, attachLViewDebug, cloneToLViewFromTViewBlueprint, cloneToTViewData, LCleanup, LViewBlueprint, MatchesArray, TCleanup, TNodeDebug, TNodeInitialInputs, TNodeLocalNames, TViewComponents, TViewConstructor} from './lview_debug';\n\n\n\n/**\n * A permanent marker promise which signifies that the current CD tree is\n * clean.\n */\nconst _CLEAN_PROMISE = (() => Promise.resolve(null))();\n\n/**\n * Invoke `HostBindingsFunction`s for view.\n *\n * This methods executes `TView.hostBindingOpCodes`. It is used to execute the\n * `HostBindingsFunction`s associated with the current `LView`.\n *\n * @param tView Current `TView`.\n * @param lView Current `LView`.\n */\nexport function processHostBindingOpCodes(tView: TView, lView: LView): void {\n  const hostBindingOpCodes = tView.hostBindingOpCodes;\n  if (hostBindingOpCodes === null) return;\n  try {\n    for (let i = 0; i < hostBindingOpCodes.length; i++) {\n      const opCode = hostBindingOpCodes[i] as number;\n      if (opCode < 0) {\n        // Negative numbers are element indexes.\n        setSelectedIndex(~opCode);\n      } else {\n        // Positive numbers are NumberTuple which store bindingRootIndex and directiveIndex.\n        const directiveIdx = opCode;\n        const bindingRootIndx = hostBindingOpCodes[++i] as number;\n        const hostBindingFn = hostBindingOpCodes[++i] as HostBindingsFunction<any>;\n        setBindingRootForHostBindings(bindingRootIndx, directiveIdx);\n        const context = lView[directiveIdx];\n        hostBindingFn(RenderFlags.Update, context);\n      }\n    }\n  } finally {\n    setSelectedIndex(-1);\n  }\n}\n\n\n/** Refreshes all content queries declared by directives in a given view */\nfunction refreshContentQueries(tView: TView, lView: LView): void {\n  const contentQueries = tView.contentQueries;\n  if (contentQueries !== null) {\n    for (let i = 0; i < contentQueries.length; i += 2) {\n      const queryStartIdx = contentQueries[i];\n      const directiveDefIdx = contentQueries[i + 1];\n      if (directiveDefIdx !== -1) {\n        const directiveDef = tView.data[directiveDefIdx] as DirectiveDef<any>;\n        ngDevMode && assertDefined(directiveDef, 'DirectiveDef not found.');\n        ngDevMode &&\n            assertDefined(directiveDef.contentQueries, 'contentQueries function should be defined');\n        setCurrentQueryIndex(queryStartIdx);\n        directiveDef.contentQueries!(RenderFlags.Update, lView[directiveDefIdx], directiveDefIdx);\n      }\n    }\n  }\n}\n\n/** Refreshes child components in the current view (update mode). */\nfunction refreshChildComponents(hostLView: LView, components: number[]): void {\n  for (let i = 0; i < components.length; i++) {\n    refreshComponent(hostLView, components[i]);\n  }\n}\n\n/** Renders child components in the current view (creation mode). */\nfunction renderChildComponents(hostLView: LView, components: number[]): void {\n  for (let i = 0; i < components.length; i++) {\n    renderComponent(hostLView, components[i]);\n  }\n}\n\nexport function createLView<T>(\n    parentLView: LView|null, tView: TView, context: T|null, flags: LViewFlags, host: RElement|null,\n    tHostNode: TNode|null, rendererFactory: RendererFactory3|null, renderer: Renderer3|null,\n    sanitizer: Sanitizer|null, injector: Injector|null): LView {\n  const lView =\n      ngDevMode ? cloneToLViewFromTViewBlueprint(tView) : tView.blueprint.slice() as LView;\n  lView[HOST] = host;\n  lView[FLAGS] = flags | LViewFlags.CreationMode | LViewFlags.Attached | LViewFlags.FirstLViewPass;\n  resetPreOrderHookFlags(lView);\n  ngDevMode && tView.declTNode && parentLView && assertTNodeForLView(tView.declTNode, parentLView);\n  lView[PARENT] = lView[DECLARATION_VIEW] = parentLView;\n  lView[CONTEXT] = context;\n  lView[RENDERER_FACTORY] = (rendererFactory || parentLView && parentLView[RENDERER_FACTORY])!;\n  ngDevMode && assertDefined(lView[RENDERER_FACTORY], 'RendererFactory is required');\n  lView[RENDERER] = (renderer || parentLView && parentLView[RENDERER])!;\n  ngDevMode && assertDefined(lView[RENDERER], 'Renderer is required');\n  lView[SANITIZER] = sanitizer || parentLView && parentLView[SANITIZER] || null!;\n  lView[INJECTOR as any] = injector || parentLView && parentLView[INJECTOR] || null;\n  lView[T_HOST] = tHostNode;\n  ngDevMode &&\n      assertEqual(\n          tView.type == TViewType.Embedded ? parentLView !== null : true, true,\n          'Embedded views must have parentLView');\n  lView[DECLARATION_COMPONENT_VIEW] =\n      tView.type == TViewType.Embedded ? parentLView![DECLARATION_COMPONENT_VIEW] : lView;\n  ngDevMode && attachLViewDebug(lView);\n  return lView;\n}\n\n/**\n * Create and stores the TNode, and hooks it up to the tree.\n *\n * @param tView The current `TView`.\n * @param index The index at which the TNode should be saved (null if view, since they are not\n * saved).\n * @param type The type of TNode to create\n * @param native The native element for this node, if applicable\n * @param name The tag name of the associated native element, if applicable\n * @param attrs Any attrs for the native element, if applicable\n */\nexport function getOrCreateTNode(\n    tView: TView, index: number, type: TNodeType.Element|TNodeType.Text, name: string|null,\n    attrs: TAttributes|null): TElementNode;\nexport function getOrCreateTNode(\n    tView: TView, index: number, type: TNodeType.Container, name: string|null,\n    attrs: TAttributes|null): TContainerNode;\nexport function getOrCreateTNode(\n    tView: TView, index: number, type: TNodeType.Projection, name: null,\n    attrs: TAttributes|null): TProjectionNode;\nexport function getOrCreateTNode(\n    tView: TView, index: number, type: TNodeType.ElementContainer, name: string|null,\n    attrs: TAttributes|null): TElementContainerNode;\nexport function getOrCreateTNode(\n    tView: TView, index: number, type: TNodeType.Icu, name: null,\n    attrs: TAttributes|null): TElementContainerNode;\nexport function getOrCreateTNode(\n    tView: TView, index: number, type: TNodeType, name: string|null, attrs: TAttributes|null):\n    TElementNode&TContainerNode&TElementContainerNode&TProjectionNode&TIcuContainerNode {\n  ngDevMode && index !== 0 &&  // 0 are bogus nodes and they are OK. See `createContainerRef` in\n                               // `view_engine_compatibility` for additional context.\n      assertGreaterThanOrEqual(index, HEADER_OFFSET, 'TNodes can\\'t be in the LView header.');\n  // Keep this function short, so that the VM will inline it.\n  ngDevMode && assertPureTNodeType(type);\n  let tNode = tView.data[index] as TNode;\n  if (tNode === null) {\n    tNode = createTNodeAtIndex(tView, index, type, name, attrs);\n    if (isInI18nBlock()) {\n      // If we are in i18n block then all elements should be pre declared through `Placeholder`\n      // See `TNodeType.Placeholder` and `LFrame.inI18n` for more context.\n      // If the `TNode` was not pre-declared than it means it was not mentioned which means it was\n      // removed, so we mark it as detached.\n      tNode.flags |= TNodeFlags.isDetached;\n    }\n  } else if (tNode.type & TNodeType.Placeholder) {\n    tNode.type = type;\n    tNode.value = name;\n    tNode.attrs = attrs;\n    const parent = getCurrentParentTNode();\n    tNode.injectorIndex = parent === null ? -1 : parent.injectorIndex;\n    ngDevMode && assertTNodeForTView(tNode, tView);\n    ngDevMode && assertEqual(index, tNode.index, 'Expecting same index');\n  }\n  setCurrentTNode(tNode, true);\n  return tNode as TElementNode & TContainerNode & TElementContainerNode & TProjectionNode &\n      TIcuContainerNode;\n}\n\nexport function createTNodeAtIndex(\n    tView: TView, index: number, type: TNodeType, name: string|null, attrs: TAttributes|null) {\n  const currentTNode = getCurrentTNodePlaceholderOk();\n  const isParent = isCurrentTNodeParent();\n  const parent = isParent ? currentTNode : currentTNode && currentTNode.parent;\n  // Parents cannot cross component boundaries because components will be used in multiple places.\n  const tNode = tView.data[index] =\n      createTNode(tView, parent as TElementNode | TContainerNode, type, index, name, attrs);\n  // Assign a pointer to the first child node of a given view. The first node is not always the one\n  // at index 0, in case of i18n, index 0 can be the instruction `i18nStart` and the first node has\n  // the index 1 or more, so we can't just check node index.\n  if (tView.firstChild === null) {\n    tView.firstChild = tNode;\n  }\n  if (currentTNode !== null) {\n    if (isParent) {\n      // FIXME(misko): This logic looks unnecessarily complicated. Could we simplify?\n      if (currentTNode.child == null && tNode.parent !== null) {\n        // We are in the same view, which means we are adding content node to the parent view.\n        currentTNode.child = tNode;\n      }\n    } else {\n      if (currentTNode.next === null) {\n        // In the case of i18n the `currentTNode` may already be linked, in which case we don't want\n        // to break the links which i18n created.\n        currentTNode.next = tNode;\n      }\n    }\n  }\n  return tNode;\n}\n\n\n/**\n * When elements are created dynamically after a view blueprint is created (e.g. through\n * i18nApply()), we need to adjust the blueprint for future\n * template passes.\n *\n * @param tView `TView` associated with `LView`\n * @param lView The `LView` containing the blueprint to adjust\n * @param numSlotsToAlloc The number of slots to alloc in the LView, should be >0\n * @param initialValue Initial value to store in blueprint\n */\nexport function allocExpando(\n    tView: TView, lView: LView, numSlotsToAlloc: number, initialValue: any): number {\n  if (numSlotsToAlloc === 0) return -1;\n  if (ngDevMode) {\n    assertFirstCreatePass(tView);\n    assertSame(tView, lView[TVIEW], '`LView` must be associated with `TView`!');\n    assertEqual(tView.data.length, lView.length, 'Expecting LView to be same size as TView');\n    assertEqual(\n        tView.data.length, tView.blueprint.length, 'Expecting Blueprint to be same size as TView');\n    assertFirstUpdatePass(tView);\n  }\n  const allocIdx = lView.length;\n  for (let i = 0; i < numSlotsToAlloc; i++) {\n    lView.push(initialValue);\n    tView.blueprint.push(initialValue);\n    tView.data.push(null);\n  }\n  return allocIdx;\n}\n\n\n//////////////////////////\n//// Render\n//////////////////////////\n\n/**\n * Processes a view in the creation mode. This includes a number of steps in a specific order:\n * - creating view query functions (if any);\n * - executing a template function in the creation mode;\n * - updating static queries (if any);\n * - creating child components defined in a given view.\n */\nexport function renderView<T>(tView: TView, lView: LView, context: T): void {\n  ngDevMode && assertEqual(isCreationMode(lView), true, 'Should be run in creation mode');\n  enterView(lView);\n  try {\n    const viewQuery = tView.viewQuery;\n    if (viewQuery !== null) {\n      executeViewQueryFn(RenderFlags.Create, viewQuery, context);\n    }\n\n    // Execute a template associated with this view, if it exists. A template function might not be\n    // defined for the root component views.\n    const templateFn = tView.template;\n    if (templateFn !== null) {\n      executeTemplate(tView, lView, templateFn, RenderFlags.Create, context);\n    }\n\n    // This needs to be set before children are processed to support recursive components.\n    // This must be set to false immediately after the first creation run because in an\n    // ngFor loop, all the views will be created together before update mode runs and turns\n    // off firstCreatePass. If we don't set it here, instances will perform directive\n    // matching, etc again and again.\n    if (tView.firstCreatePass) {\n      tView.firstCreatePass = false;\n    }\n\n    // We resolve content queries specifically marked as `static` in creation mode. Dynamic\n    // content queries are resolved during change detection (i.e. update mode), after embedded\n    // views are refreshed (see block above).\n    if (tView.staticContentQueries) {\n      refreshContentQueries(tView, lView);\n    }\n\n    // We must materialize query results before child components are processed\n    // in case a child component has projected a container. The LContainer needs\n    // to exist so the embedded views are properly attached by the container.\n    if (tView.staticViewQueries) {\n      executeViewQueryFn(RenderFlags.Update, tView.viewQuery!, context);\n    }\n\n    // Render child component views.\n    const components = tView.components;\n    if (components !== null) {\n      renderChildComponents(lView, components);\n    }\n\n  } catch (error) {\n    // If we didn't manage to get past the first template pass due to\n    // an error, mark the view as corrupted so we can try to recover.\n    if (tView.firstCreatePass) {\n      tView.incompleteFirstPass = true;\n      tView.firstCreatePass = false;\n    }\n\n    throw error;\n  } finally {\n    lView[FLAGS] &= ~LViewFlags.CreationMode;\n    leaveView();\n  }\n}\n\n/**\n * Processes a view in update mode. This includes a number of steps in a specific order:\n * - executing a template function in update mode;\n * - executing hooks;\n * - refreshing queries;\n * - setting host bindings;\n * - refreshing child (embedded and component) views.\n */\nexport function refreshView<T>(\n    tView: TView, lView: LView, templateFn: ComponentTemplate<{}>|null, context: T) {\n  ngDevMode && assertEqual(isCreationMode(lView), false, 'Should be run in update mode');\n  const flags = lView[FLAGS];\n  if ((flags & LViewFlags.Destroyed) === LViewFlags.Destroyed) return;\n  enterView(lView);\n  // Check no changes mode is a dev only mode used to verify that bindings have not changed\n  // since they were assigned. We do not want to execute lifecycle hooks in that mode.\n  const isInCheckNoChangesPass = isInCheckNoChangesMode();\n  try {\n    resetPreOrderHookFlags(lView);\n\n    setBindingIndex(tView.bindingStartIndex);\n    if (templateFn !== null) {\n      executeTemplate(tView, lView, templateFn, RenderFlags.Update, context);\n    }\n\n    const hooksInitPhaseCompleted =\n        (flags & LViewFlags.InitPhaseStateMask) === InitPhaseState.InitPhaseCompleted;\n\n    // execute pre-order hooks (OnInit, OnChanges, DoCheck)\n    // PERF WARNING: do NOT extract this to a separate function without running benchmarks\n    if (!isInCheckNoChangesPass) {\n      if (hooksInitPhaseCompleted) {\n        const preOrderCheckHooks = tView.preOrderCheckHooks;\n        if (preOrderCheckHooks !== null) {\n          executeCheckHooks(lView, preOrderCheckHooks, null);\n        }\n      } else {\n        const preOrderHooks = tView.preOrderHooks;\n        if (preOrderHooks !== null) {\n          executeInitAndCheckHooks(lView, preOrderHooks, InitPhaseState.OnInitHooksToBeRun, null);\n        }\n        incrementInitPhaseFlags(lView, InitPhaseState.OnInitHooksToBeRun);\n      }\n    }\n\n    // First mark transplanted views that are declared in this lView as needing a refresh at their\n    // insertion points. This is needed to avoid the situation where the template is defined in this\n    // `LView` but its declaration appears after the insertion component.\n    markTransplantedViewsForRefresh(lView);\n    refreshEmbeddedViews(lView);\n\n    // Content query results must be refreshed before content hooks are called.\n    if (tView.contentQueries !== null) {\n      refreshContentQueries(tView, lView);\n    }\n\n    // execute content hooks (AfterContentInit, AfterContentChecked)\n    // PERF WARNING: do NOT extract this to a separate function without running benchmarks\n    if (!isInCheckNoChangesPass) {\n      if (hooksInitPhaseCompleted) {\n        const contentCheckHooks = tView.contentCheckHooks;\n        if (contentCheckHooks !== null) {\n          executeCheckHooks(lView, contentCheckHooks);\n        }\n      } else {\n        const contentHooks = tView.contentHooks;\n        if (contentHooks !== null) {\n          executeInitAndCheckHooks(\n              lView, contentHooks, InitPhaseState.AfterContentInitHooksToBeRun);\n        }\n        incrementInitPhaseFlags(lView, InitPhaseState.AfterContentInitHooksToBeRun);\n      }\n    }\n\n    processHostBindingOpCodes(tView, lView);\n\n    // Refresh child component views.\n    const components = tView.components;\n    if (components !== null) {\n      refreshChildComponents(lView, components);\n    }\n\n    // View queries must execute after refreshing child components because a template in this view\n    // could be inserted in a child component. If the view query executes before child component\n    // refresh, the template might not yet be inserted.\n    const viewQuery = tView.viewQuery;\n    if (viewQuery !== null) {\n      executeViewQueryFn(RenderFlags.Update, viewQuery, context);\n    }\n\n    // execute view hooks (AfterViewInit, AfterViewChecked)\n    // PERF WARNING: do NOT extract this to a separate function without running benchmarks\n    if (!isInCheckNoChangesPass) {\n      if (hooksInitPhaseCompleted) {\n        const viewCheckHooks = tView.viewCheckHooks;\n        if (viewCheckHooks !== null) {\n          executeCheckHooks(lView, viewCheckHooks);\n        }\n      } else {\n        const viewHooks = tView.viewHooks;\n        if (viewHooks !== null) {\n          executeInitAndCheckHooks(lView, viewHooks, InitPhaseState.AfterViewInitHooksToBeRun);\n        }\n        incrementInitPhaseFlags(lView, InitPhaseState.AfterViewInitHooksToBeRun);\n      }\n    }\n    if (tView.firstUpdatePass === true) {\n      // We need to make sure that we only flip the flag on successful `refreshView` only\n      // Don't do this in `finally` block.\n      // If we did this in `finally` block then an exception could block the execution of styling\n      // instructions which in turn would be unable to insert themselves into the styling linked\n      // list. The result of this would be that if the exception would not be throw on subsequent CD\n      // the styling would be unable to process it data and reflect to the DOM.\n      tView.firstUpdatePass = false;\n    }\n\n    // Do not reset the dirty state when running in check no changes mode. We don't want components\n    // to behave differently depending on whether check no changes is enabled or not. For example:\n    // Marking an OnPush component as dirty from within the `ngAfterViewInit` hook in order to\n    // refresh a `NgClass` binding should work. If we would reset the dirty state in the check\n    // no changes cycle, the component would be not be dirty for the next update pass. This would\n    // be different in production mode where the component dirty state is not reset.\n    if (!isInCheckNoChangesPass) {\n      lView[FLAGS] &= ~(LViewFlags.Dirty | LViewFlags.FirstLViewPass);\n    }\n    if (lView[FLAGS] & LViewFlags.RefreshTransplantedView) {\n      lView[FLAGS] &= ~LViewFlags.RefreshTransplantedView;\n      updateTransplantedViewCount(lView[PARENT] as LContainer, -1);\n    }\n  } finally {\n    leaveView();\n  }\n}\n\nexport function renderComponentOrTemplate<T>(\n    tView: TView, lView: LView, templateFn: ComponentTemplate<{}>|null, context: T) {\n  const rendererFactory = lView[RENDERER_FACTORY];\n  const normalExecutionPath = !isInCheckNoChangesMode();\n  const creationModeIsActive = isCreationMode(lView);\n  try {\n    if (normalExecutionPath && !creationModeIsActive && rendererFactory.begin) {\n      rendererFactory.begin();\n    }\n    if (creationModeIsActive) {\n      renderView(tView, lView, context);\n    }\n    refreshView(tView, lView, templateFn, context);\n  } finally {\n    if (normalExecutionPath && !creationModeIsActive && rendererFactory.end) {\n      rendererFactory.end();\n    }\n  }\n}\n\nfunction executeTemplate<T>(\n    tView: TView, lView: LView, templateFn: ComponentTemplate<T>, rf: RenderFlags, context: T) {\n  const prevSelectedIndex = getSelectedIndex();\n  const isUpdatePhase = rf & RenderFlags.Update;\n  try {\n    setSelectedIndex(-1);\n    if (isUpdatePhase && lView.length > HEADER_OFFSET) {\n      // When we're updating, inherently select 0 so we don't\n      // have to generate that instruction for most update blocks.\n      selectIndexInternal(tView, lView, HEADER_OFFSET, isInCheckNoChangesMode());\n    }\n\n    const preHookType =\n        isUpdatePhase ? ProfilerEvent.TemplateUpdateStart : ProfilerEvent.TemplateCreateStart;\n    profiler(preHookType, context);\n    templateFn(rf, context);\n  } finally {\n    setSelectedIndex(prevSelectedIndex);\n\n    const postHookType =\n        isUpdatePhase ? ProfilerEvent.TemplateUpdateEnd : ProfilerEvent.TemplateCreateEnd;\n    profiler(postHookType, context);\n  }\n}\n\n//////////////////////////\n//// Element\n//////////////////////////\n\nexport function executeContentQueries(tView: TView, tNode: TNode, lView: LView) {\n  if (isContentQueryHost(tNode)) {\n    const start = tNode.directiveStart;\n    const end = tNode.directiveEnd;\n    for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {\n      const def = tView.data[directiveIndex] as DirectiveDef<any>;\n      if (def.contentQueries) {\n        def.contentQueries(RenderFlags.Create, lView[directiveIndex], directiveIndex);\n      }\n    }\n  }\n}\n\n\n/**\n * Creates directive instances.\n */\nexport function createDirectivesInstances(tView: TView, lView: LView, tNode: TDirectiveHostNode) {\n  if (!getBindingsEnabled()) return;\n  instantiateAllDirectives(tView, lView, tNode, getNativeByTNode(tNode, lView));\n  if ((tNode.flags & TNodeFlags.hasHostBindings) === TNodeFlags.hasHostBindings) {\n    invokeDirectivesHostBindings(tView, lView, tNode);\n  }\n}\n\n/**\n * Takes a list of local names and indices and pushes the resolved local variable values\n * to LView in the same order as they are loaded in the template with load().\n */\nexport function saveResolvedLocalsInData(\n    viewData: LView, tNode: TDirectiveHostNode,\n    localRefExtractor: LocalRefExtractor = getNativeByTNode): void {\n  const localNames = tNode.localNames;\n  if (localNames !== null) {\n    let localIndex = tNode.index + 1;\n    for (let i = 0; i < localNames.length; i += 2) {\n      const index = localNames[i + 1] as number;\n      const value = index === -1 ?\n          localRefExtractor(\n              tNode as TElementNode | TContainerNode | TElementContainerNode, viewData) :\n          viewData[index];\n      viewData[localIndex++] = value;\n    }\n  }\n}\n\n/**\n * Gets TView from a template function or creates a new TView\n * if it doesn't already exist.\n *\n * @param def ComponentDef\n * @returns TView\n */\nexport function getOrCreateTComponentView(def: ComponentDef<any>): TView {\n  const tView = def.tView;\n\n  // Create a TView if there isn't one, or recreate it if the first create pass didn't\n  // complete successfully since we can't know for sure whether it's in a usable shape.\n  if (tView === null || tView.incompleteFirstPass) {\n    // Declaration node here is null since this function is called when we dynamically create a\n    // component and hence there is no declaration.\n    const declTNode = null;\n    return def.tView = createTView(\n               TViewType.Component, declTNode, def.template, def.decls, def.vars, def.directiveDefs,\n               def.pipeDefs, def.viewQuery, def.schemas, def.consts);\n  }\n\n  return tView;\n}\n\n\n/**\n * Creates a TView instance\n *\n * @param type Type of `TView`.\n * @param declTNode Declaration location of this `TView`.\n * @param templateFn Template function\n * @param decls The number of nodes, local refs, and pipes in this template\n * @param directives Registry of directives for this view\n * @param pipes Registry of pipes for this view\n * @param viewQuery View queries for this view\n * @param schemas Schemas for this view\n * @param consts Constants for this view\n */\nexport function createTView(\n    type: TViewType, declTNode: TNode|null, templateFn: ComponentTemplate<any>|null, decls: number,\n    vars: number, directives: DirectiveDefListOrFactory|null, pipes: PipeDefListOrFactory|null,\n    viewQuery: ViewQueriesFunction<any>|null, schemas: SchemaMetadata[]|null,\n    constsOrFactory: TConstantsOrFactory|null): TView {\n  ngDevMode && ngDevMode.tView++;\n  const bindingStartIndex = HEADER_OFFSET + decls;\n  // This length does not yet contain host bindings from child directives because at this point,\n  // we don't know which directives are active on this template. As soon as a directive is matched\n  // that has a host binding, we will update the blueprint with that def's hostVars count.\n  const initialViewLength = bindingStartIndex + vars;\n  const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);\n  const consts = typeof constsOrFactory === 'function' ? constsOrFactory() : constsOrFactory;\n  const tView = blueprint[TVIEW as any] = ngDevMode ?\n      new TViewConstructor(\n          type,        // type: TViewType,\n          blueprint,   // blueprint: LView,\n          templateFn,  // template: ComponentTemplate<{}>|null,\n          null,        // queries: TQueries|null\n          viewQuery,   // viewQuery: ViewQueriesFunction<{}>|null,\n          declTNode,   // declTNode: TNode|null,\n          cloneToTViewData(blueprint).fill(null, bindingStartIndex),  // data: TData,\n          bindingStartIndex,                                          // bindingStartIndex: number,\n          initialViewLength,                                          // expandoStartIndex: number,\n          null,                               // hostBindingOpCodes: HostBindingOpCodes,\n          true,                               // firstCreatePass: boolean,\n          true,                               // firstUpdatePass: boolean,\n          false,                              // staticViewQueries: boolean,\n          false,                              // staticContentQueries: boolean,\n          null,                               // preOrderHooks: HookData|null,\n          null,                               // preOrderCheckHooks: HookData|null,\n          null,                               // contentHooks: HookData|null,\n          null,                               // contentCheckHooks: HookData|null,\n          null,                               // viewHooks: HookData|null,\n          null,                               // viewCheckHooks: HookData|null,\n          null,                               // destroyHooks: DestroyHookData|null,\n          null,                               // cleanup: any[]|null,\n          null,                               // contentQueries: number[]|null,\n          null,                               // components: number[]|null,\n          typeof directives === 'function' ?  //\n              directives() :                  //\n              directives,                     // directiveRegistry: DirectiveDefList|null,\n          typeof pipes === 'function' ? pipes() : pipes,  // pipeRegistry: PipeDefList|null,\n          null,                                           // firstChild: TNode|null,\n          schemas,                                        // schemas: SchemaMetadata[]|null,\n          consts,                                         // consts: TConstants|null\n          false,                                          // incompleteFirstPass: boolean\n          decls,                                          // ngDevMode only: decls\n          vars,                                           // ngDevMode only: vars\n          ) :\n      {\n        type: type,\n        blueprint: blueprint,\n        template: templateFn,\n        queries: null,\n        viewQuery: viewQuery,\n        declTNode: declTNode,\n        data: blueprint.slice().fill(null, bindingStartIndex),\n        bindingStartIndex: bindingStartIndex,\n        expandoStartIndex: initialViewLength,\n        hostBindingOpCodes: null,\n        firstCreatePass: true,\n        firstUpdatePass: true,\n        staticViewQueries: false,\n        staticContentQueries: false,\n        preOrderHooks: null,\n        preOrderCheckHooks: null,\n        contentHooks: null,\n        contentCheckHooks: null,\n        viewHooks: null,\n        viewCheckHooks: null,\n        destroyHooks: null,\n        cleanup: null,\n        contentQueries: null,\n        components: null,\n        directiveRegistry: typeof directives === 'function' ? directives() : directives,\n        pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,\n        firstChild: null,\n        schemas: schemas,\n        consts: consts,\n        incompleteFirstPass: false\n      };\n  if (ngDevMode) {\n    // For performance reasons it is important that the tView retains the same shape during runtime.\n    // (To make sure that all of the code is monomorphic.) For this reason we seal the object to\n    // prevent class transitions.\n    Object.seal(tView);\n  }\n  return tView;\n}\n\nfunction createViewBlueprint(bindingStartIndex: number, initialViewLength: number): LView {\n  const blueprint = ngDevMode ? new LViewBlueprint() : [];\n\n  for (let i = 0; i < initialViewLength; i++) {\n    blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);\n  }\n\n  return blueprint as LView;\n}\n\nfunction createError(text: string, token: any) {\n  return new Error(`Renderer: ${text} [${stringifyForError(token)}]`);\n}\n\nfunction assertHostNodeExists(rElement: RElement, elementOrSelector: RElement|string) {\n  if (!rElement) {\n    if (typeof elementOrSelector === 'string') {\n      throw createError('Host node with selector not found:', elementOrSelector);\n    } else {\n      throw createError('Host node is required:', elementOrSelector);\n    }\n  }\n}\n\n/**\n * Locates the host native element, used for bootstrapping existing nodes into rendering pipeline.\n *\n * @param rendererFactory Factory function to create renderer instance.\n * @param elementOrSelector Render element or CSS selector to locate the element.\n * @param encapsulation View Encapsulation defined for component that requests host element.\n */\nexport function locateHostElement(\n    renderer: Renderer3, elementOrSelector: RElement|string,\n    encapsulation: ViewEncapsulation): RElement {\n  if (isProceduralRenderer(renderer)) {\n    // When using native Shadow DOM, do not clear host element to allow native slot projection\n    const preserveContent = encapsulation === ViewEncapsulation.ShadowDom;\n    return renderer.selectRootElement(elementOrSelector, preserveContent);\n  }\n\n  let rElement = typeof elementOrSelector === 'string' ?\n      renderer.querySelector(elementOrSelector)! :\n      elementOrSelector;\n  ngDevMode && assertHostNodeExists(rElement, elementOrSelector);\n\n  // Always clear host element's content when Renderer3 is in use. For procedural renderer case we\n  // make it depend on whether ShadowDom encapsulation is used (in which case the content should be\n  // preserved to allow native slot projection). ShadowDom encapsulation requires procedural\n  // renderer, and procedural renderer case is handled above.\n  rElement.textContent = '';\n\n  return rElement;\n}\n\n/**\n * Saves context for this cleanup function in LView.cleanupInstances.\n *\n * On the first template pass, saves in TView:\n * - Cleanup function\n * - Index of context we just saved in LView.cleanupInstances\n *\n * This function can also be used to store instance specific cleanup fns. In that case the `context`\n * is `null` and the function is store in `LView` (rather than it `TView`).\n */\nexport function storeCleanupWithContext(\n    tView: TView, lView: LView, context: any, cleanupFn: Function): void {\n  const lCleanup = getOrCreateLViewCleanup(lView);\n  if (context === null) {\n    // If context is null that this is instance specific callback. These callbacks can only be\n    // inserted after template shared instances. For this reason in ngDevMode we freeze the TView.\n    if (ngDevMode) {\n      Object.freeze(getOrCreateTViewCleanup(tView));\n    }\n    lCleanup.push(cleanupFn);\n  } else {\n    lCleanup.push(context);\n\n    if (tView.firstCreatePass) {\n      getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);\n    }\n  }\n}\n\n/**\n * Constructs a TNode object from the arguments.\n *\n * @param tView `TView` to which this `TNode` belongs (used only in `ngDevMode`)\n * @param tParent Parent `TNode`\n * @param type The type of the node\n * @param index The index of the TNode in TView.data, adjusted for HEADER_OFFSET\n * @param tagName The tag name of the node\n * @param attrs The attributes defined on this node\n * @param tViews Any TViews attached to this node\n * @returns the TNode object\n */\nexport function createTNode(\n    tView: TView, tParent: TElementNode|TContainerNode|null, type: TNodeType.Container,\n    index: number, tagName: string|null, attrs: TAttributes|null): TContainerNode;\nexport function createTNode(\n    tView: TView, tParent: TElementNode|TContainerNode|null, type: TNodeType.Element|TNodeType.Text,\n    index: number, tagName: string|null, attrs: TAttributes|null): TElementNode;\nexport function createTNode(\n    tView: TView, tParent: TElementNode|TContainerNode|null, type: TNodeType.ElementContainer,\n    index: number, tagName: string|null, attrs: TAttributes|null): TElementContainerNode;\nexport function createTNode(\n    tView: TView, tParent: TElementNode|TContainerNode|null, type: TNodeType.Icu, index: number,\n    tagName: string|null, attrs: TAttributes|null): TIcuContainerNode;\nexport function createTNode(\n    tView: TView, tParent: TElementNode|TContainerNode|null, type: TNodeType.Projection,\n    index: number, tagName: string|null, attrs: TAttributes|null): TProjectionNode;\nexport function createTNode(\n    tView: TView, tParent: TElementNode|TContainerNode|null, type: TNodeType, index: number,\n    tagName: string|null, attrs: TAttributes|null): TNode;\nexport function createTNode(\n    tView: TView, tParent: TElementNode|TContainerNode|null, type: TNodeType, index: number,\n    value: string|null, attrs: TAttributes|null): TNode {\n  ngDevMode && index !== 0 &&  // 0 are bogus nodes and they are OK. See `createContainerRef` in\n                               // `view_engine_compatibility` for additional context.\n      assertGreaterThanOrEqual(index, HEADER_OFFSET, 'TNodes can\\'t be in the LView header.');\n  ngDevMode && assertNotSame(attrs, undefined, '\\'undefined\\' is not valid value for \\'attrs\\'');\n  ngDevMode && ngDevMode.tNode++;\n  ngDevMode && tParent && assertTNodeForTView(tParent, tView);\n  let injectorIndex = tParent ? tParent.injectorIndex : -1;\n  const tNode = ngDevMode ?\n      new TNodeDebug(\n          tView,          // tView_: TView\n          type,           // type: TNodeType\n          index,          // index: number\n          null,           // insertBeforeIndex: null|-1|number|number[]\n          injectorIndex,  // injectorIndex: number\n          -1,             // directiveStart: number\n          -1,             // directiveEnd: number\n          -1,             // directiveStylingLast: number\n          null,           // propertyBindings: number[]|null\n          0,              // flags: TNodeFlags\n          0,              // providerIndexes: TNodeProviderIndexes\n          value,          // value: string|null\n          attrs,          // attrs: (string|AttributeMarker|(string|SelectorFlags)[])[]|null\n          null,           // mergedAttrs\n          null,           // localNames: (string|number)[]|null\n          undefined,      // initialInputs: (string[]|null)[]|null|undefined\n          null,           // inputs: PropertyAliases|null\n          null,           // outputs: PropertyAliases|null\n          null,           // tViews: ITView|ITView[]|null\n          null,           // next: ITNode|null\n          null,           // projectionNext: ITNode|null\n          null,           // child: ITNode|null\n          tParent,        // parent: TElementNode|TContainerNode|null\n          null,           // projection: number|(ITNode|RNode[])[]|null\n          null,           // styles: string|null\n          null,           // stylesWithoutHost: string|null\n          undefined,      // residualStyles: string|null\n          null,           // classes: string|null\n          null,           // classesWithoutHost: string|null\n          undefined,      // residualClasses: string|null\n          0 as any,       // classBindings: TStylingRange;\n          0 as any,       // styleBindings: TStylingRange;\n          ) :\n      {\n        type,\n        index,\n        insertBeforeIndex: null,\n        injectorIndex,\n        directiveStart: -1,\n        directiveEnd: -1,\n        directiveStylingLast: -1,\n        propertyBindings: null,\n        flags: 0,\n        providerIndexes: 0,\n        value: value,\n        attrs: attrs,\n        mergedAttrs: null,\n        localNames: null,\n        initialInputs: undefined,\n        inputs: null,\n        outputs: null,\n        tViews: null,\n        next: null,\n        projectionNext: null,\n        child: null,\n        parent: tParent,\n        projection: null,\n        styles: null,\n        stylesWithoutHost: null,\n        residualStyles: undefined,\n        classes: null,\n        classesWithoutHost: null,\n        residualClasses: undefined,\n        classBindings: 0 as any,\n        styleBindings: 0 as any,\n      };\n  if (ngDevMode) {\n    // For performance reasons it is important that the tNode retains the same shape during runtime.\n    // (To make sure that all of the code is monomorphic.) For this reason we seal the object to\n    // prevent class transitions.\n    Object.seal(tNode);\n  }\n  return tNode;\n}\n\n\nfunction generatePropertyAliases(\n    inputAliasMap: {[publicName: string]: string}, directiveDefIdx: number,\n    propStore: PropertyAliases|null): PropertyAliases|null {\n  for (let publicName in inputAliasMap) {\n    if (inputAliasMap.hasOwnProperty(publicName)) {\n      propStore = propStore === null ? {} : propStore;\n      const internalName = inputAliasMap[publicName];\n\n      if (propStore.hasOwnProperty(publicName)) {\n        propStore[publicName].push(directiveDefIdx, internalName);\n      } else {\n        (propStore[publicName] = [directiveDefIdx, internalName]);\n      }\n    }\n  }\n  return propStore;\n}\n\n/**\n * Initializes data structures required to work with directive inputs and outputs.\n * Initialization is done for all directives matched on a given TNode.\n */\nfunction initializeInputAndOutputAliases(tView: TView, tNode: TNode): void {\n  ngDevMode && assertFirstCreatePass(tView);\n\n  const start = tNode.directiveStart;\n  const end = tNode.directiveEnd;\n  const tViewData = tView.data;\n\n  const tNodeAttrs = tNode.attrs;\n  const inputsFromAttrs: InitialInputData = ngDevMode ? new TNodeInitialInputs() : [];\n  let inputsStore: PropertyAliases|null = null;\n  let outputsStore: PropertyAliases|null = null;\n  for (let i = start; i < end; i++) {\n    const directiveDef = tViewData[i] as DirectiveDef<any>;\n    const directiveInputs = directiveDef.inputs;\n    // Do not use unbound attributes as inputs to structural directives, since structural\n    // directive inputs can only be set using microsyntax (e.g. `<div *dir=\"exp\">`).\n    // TODO(FW-1930): microsyntax expressions may also contain unbound/static attributes, which\n    // should be set for inline templates.\n    const initialInputs = (tNodeAttrs !== null && !isInlineTemplate(tNode)) ?\n        generateInitialInputs(directiveInputs, tNodeAttrs) :\n        null;\n    inputsFromAttrs.push(initialInputs);\n    inputsStore = generatePropertyAliases(directiveInputs, i, inputsStore);\n    outputsStore = generatePropertyAliases(directiveDef.outputs, i, outputsStore);\n  }\n\n  if (inputsStore !== null) {\n    if (inputsStore.hasOwnProperty('class')) {\n      tNode.flags |= TNodeFlags.hasClassInput;\n    }\n    if (inputsStore.hasOwnProperty('style')) {\n      tNode.flags |= TNodeFlags.hasStyleInput;\n    }\n  }\n\n  tNode.initialInputs = inputsFromAttrs;\n  tNode.inputs = inputsStore;\n  tNode.outputs = outputsStore;\n}\n\n/**\n * Mapping between attributes names that don't correspond to their element property names.\n *\n * Performance note: this function is written as a series of if checks (instead of, say, a property\n * object lookup) for performance reasons - the series of `if` checks seems to be the fastest way of\n * mapping property names. Do NOT change without benchmarking.\n *\n * Note: this mapping has to be kept in sync with the equally named mapping in the template\n * type-checking machinery of ngtsc.\n */\nfunction mapPropName(name: string): string {\n  if (name === 'class') return 'className';\n  if (name === 'for') return 'htmlFor';\n  if (name === 'formaction') return 'formAction';\n  if (name === 'innerHtml') return 'innerHTML';\n  if (name === 'readonly') return 'readOnly';\n  if (name === 'tabindex') return 'tabIndex';\n  return name;\n}\n\nexport function elementPropertyInternal<T>(\n    tView: TView, tNode: TNode, lView: LView, propName: string, value: T, renderer: Renderer3,\n    sanitizer: SanitizerFn|null|undefined, nativeOnly: boolean): void {\n  ngDevMode && assertNotSame(value, NO_CHANGE as any, 'Incoming value should never be NO_CHANGE.');\n  const element = getNativeByTNode(tNode, lView) as RElement | RComment;\n  let inputData = tNode.inputs;\n  let dataValue: PropertyAliasValue|undefined;\n  if (!nativeOnly && inputData != null && (dataValue = inputData[propName])) {\n    setInputsForProperty(tView, lView, dataValue, propName, value);\n    if (isComponentHost(tNode)) markDirtyIfOnPush(lView, tNode.index);\n    if (ngDevMode) {\n      setNgReflectProperties(lView, element, tNode.type, dataValue, value);\n    }\n  } else if (tNode.type & TNodeType.AnyRNode) {\n    propName = mapPropName(propName);\n\n    if (ngDevMode) {\n      validateAgainstEventProperties(propName);\n      if (!validateProperty(tView, element, propName, tNode)) {\n        // Return here since we only log warnings for unknown properties.\n        logUnknownPropertyError(propName, tNode);\n        return;\n      }\n      ngDevMode.rendererSetProperty++;\n    }\n\n    // It is assumed that the sanitizer is only added when the compiler determines that the\n    // property is risky, so sanitization can be done without further checks.\n    value = sanitizer != null ? (sanitizer(value, tNode.value || '', propName) as any) : value;\n    if (isProceduralRenderer(renderer)) {\n      renderer.setProperty(element as RElement, propName, value);\n    } else if (!isAnimationProp(propName)) {\n      (element as RElement).setProperty ? (element as any).setProperty(propName, value) :\n                                          (element as any)[propName] = value;\n    }\n  } else if (tNode.type & TNodeType.AnyContainer) {\n    // If the node is a container and the property didn't\n    // match any of the inputs or schemas we should throw.\n    if (ngDevMode && !matchingSchemas(tView, tNode.value)) {\n      logUnknownPropertyError(propName, tNode);\n    }\n  }\n}\n\n/** If node is an OnPush component, marks its LView dirty. */\nfunction markDirtyIfOnPush(lView: LView, viewIndex: number): void {\n  ngDevMode && assertLView(lView);\n  const childComponentLView = getComponentLViewByIndex(viewIndex, lView);\n  if (!(childComponentLView[FLAGS] & LViewFlags.CheckAlways)) {\n    childComponentLView[FLAGS] |= LViewFlags.Dirty;\n  }\n}\n\nfunction setNgReflectProperty(\n    lView: LView, element: RElement|RComment, type: TNodeType, attrName: string, value: any) {\n  const renderer = lView[RENDERER];\n  attrName = normalizeDebugBindingName(attrName);\n  const debugValue = normalizeDebugBindingValue(value);\n  if (type & TNodeType.AnyRNode) {\n    if (value == null) {\n      isProceduralRenderer(renderer) ? renderer.removeAttribute((element as RElement), attrName) :\n                                       (element as RElement).removeAttribute(attrName);\n    } else {\n      isProceduralRenderer(renderer) ?\n          renderer.setAttribute((element as RElement), attrName, debugValue) :\n          (element as RElement).setAttribute(attrName, debugValue);\n    }\n  } else {\n    const textContent =\n        escapeCommentText(`bindings=${JSON.stringify({[attrName]: debugValue}, null, 2)}`);\n    if (isProceduralRenderer(renderer)) {\n      renderer.setValue((element as RComment), textContent);\n    } else {\n      (element as RComment).textContent = textContent;\n    }\n  }\n}\n\nexport function setNgReflectProperties(\n    lView: LView, element: RElement|RComment, type: TNodeType, dataValue: PropertyAliasValue,\n    value: any) {\n  if (type & (TNodeType.AnyRNode | TNodeType.Container)) {\n    /**\n     * dataValue is an array containing runtime input or output names for the directives:\n     * i+0: directive instance index\n     * i+1: privateName\n     *\n     * e.g. [0, 'change', 'change-minified']\n     * we want to set the reflected property with the privateName: dataValue[i+1]\n     */\n    for (let i = 0; i < dataValue.length; i += 2) {\n      setNgReflectProperty(lView, element, type, dataValue[i + 1] as string, value);\n    }\n  }\n}\n\nfunction validateProperty(\n    tView: TView, element: RElement|RComment, propName: string, tNode: TNode): boolean {\n  // If `schemas` is set to `null`, that's an indication that this Component was compiled in AOT\n  // mode where this check happens at compile time. In JIT mode, `schemas` is always present and\n  // defined as an array (as an empty array in case `schemas` field is not defined) and we should\n  // execute the check below.\n  if (tView.schemas === null) return true;\n\n  // The property is considered valid if the element matches the schema, it exists on the element\n  // or it is synthetic, and we are in a browser context (web worker nodes should be skipped).\n  if (matchingSchemas(tView, tNode.value) || propName in element || isAnimationProp(propName)) {\n    return true;\n  }\n\n  // Note: `typeof Node` returns 'function' in most browsers, but on IE it is 'object' so we\n  // need to account for both here, while being careful for `typeof null` also returning 'object'.\n  return typeof Node === 'undefined' || Node === null || !(element instanceof Node);\n}\n\nexport function matchingSchemas(tView: TView, tagName: string|null): boolean {\n  const schemas = tView.schemas;\n\n  if (schemas !== null) {\n    for (let i = 0; i < schemas.length; i++) {\n      const schema = schemas[i];\n      if (schema === NO_ERRORS_SCHEMA ||\n          schema === CUSTOM_ELEMENTS_SCHEMA && tagName && tagName.indexOf('-') > -1) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\n/**\n * Logs an error that a property is not supported on an element.\n * @param propName Name of the invalid property.\n * @param tNode Node on which we encountered the property.\n */\nfunction logUnknownPropertyError(propName: string, tNode: TNode): void {\n  let message = `Can't bind to '${propName}' since it isn't a known property of '${tNode.value}'.`;\n  console.error(formatRuntimeError(RuntimeErrorCode.UNKNOWN_BINDING, message));\n}\n\n/**\n * Instantiate a root component.\n */\nexport function instantiateRootComponent<T>(tView: TView, lView: LView, def: ComponentDef<T>): T {\n  const rootTNode = getCurrentTNode()!;\n  if (tView.firstCreatePass) {\n    if (def.providersResolver) def.providersResolver(def);\n    const directiveIndex = allocExpando(tView, lView, 1, null);\n    ngDevMode &&\n        assertEqual(\n            directiveIndex, rootTNode.directiveStart,\n            'Because this is a root component the allocated expando should match the TNode component.');\n    configureViewWithDirective(tView, rootTNode, lView, directiveIndex, def);\n  }\n  const directive =\n      getNodeInjectable(lView, tView, rootTNode.directiveStart, rootTNode as TElementNode);\n  attachPatchData(directive, lView);\n  const native = getNativeByTNode(rootTNode, lView);\n  if (native) {\n    attachPatchData(native, lView);\n  }\n  return directive;\n}\n\n/**\n * Resolve the matched directives on a node.\n */\nexport function resolveDirectives(\n    tView: TView, lView: LView, tNode: TElementNode|TContainerNode|TElementContainerNode,\n    localRefs: string[]|null): boolean {\n  // Please make sure to have explicit type for `exportsMap`. Inferred type triggers bug in\n  // tsickle.\n  ngDevMode && assertFirstCreatePass(tView);\n\n  let hasDirectives = false;\n  if (getBindingsEnabled()) {\n    const directiveDefs: DirectiveDef<any>[]|null = findDirectiveDefMatches(tView, lView, tNode);\n    const exportsMap: ({[key: string]: number}|null) = localRefs === null ? null : {'': -1};\n\n    if (directiveDefs !== null) {\n      hasDirectives = true;\n      initTNodeFlags(tNode, tView.data.length, directiveDefs.length);\n      // When the same token is provided by several directives on the same node, some rules apply in\n      // the viewEngine:\n      // - viewProviders have priority over providers\n      // - the last directive in NgModule.declarations has priority over the previous one\n      // So to match these rules, the order in which providers are added in the arrays is very\n      // important.\n      for (let i = 0; i < directiveDefs.length; i++) {\n        const def = directiveDefs[i];\n        if (def.providersResolver) def.providersResolver(def);\n      }\n      let preOrderHooksFound = false;\n      let preOrderCheckHooksFound = false;\n      let directiveIdx = allocExpando(tView, lView, directiveDefs.length, null);\n      ngDevMode &&\n          assertSame(\n              directiveIdx, tNode.directiveStart,\n              'TNode.directiveStart should point to just allocated space');\n\n      for (let i = 0; i < directiveDefs.length; i++) {\n        const def = directiveDefs[i];\n        // Merge the attrs in the order of matches. This assumes that the first directive is the\n        // component itself, so that the component has the least priority.\n        tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, def.hostAttrs);\n\n        configureViewWithDirective(tView, tNode, lView, directiveIdx, def);\n        saveNameToExportMap(directiveIdx, def, exportsMap);\n\n        if (def.contentQueries !== null) tNode.flags |= TNodeFlags.hasContentQuery;\n        if (def.hostBindings !== null || def.hostAttrs !== null || def.hostVars !== 0)\n          tNode.flags |= TNodeFlags.hasHostBindings;\n\n        const lifeCycleHooks: OnChanges&OnInit&DoCheck = def.type.prototype;\n        // Only push a node index into the preOrderHooks array if this is the first\n        // pre-order hook found on this node.\n        if (!preOrderHooksFound &&\n            (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngOnInit || lifeCycleHooks.ngDoCheck)) {\n          // We will push the actual hook function into this array later during dir instantiation.\n          // We cannot do it now because we must ensure hooks are registered in the same\n          // order that directives are created (i.e. injection order).\n          (tView.preOrderHooks || (tView.preOrderHooks = [])).push(tNode.index);\n          preOrderHooksFound = true;\n        }\n\n        if (!preOrderCheckHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngDoCheck)) {\n          (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(tNode.index);\n          preOrderCheckHooksFound = true;\n        }\n\n        directiveIdx++;\n      }\n\n      initializeInputAndOutputAliases(tView, tNode);\n    }\n    if (exportsMap) cacheMatchingLocalNames(tNode, localRefs, exportsMap);\n  }\n  // Merge the template attrs last so that they have the highest priority.\n  tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);\n  return hasDirectives;\n}\n\n/**\n * Add `hostBindings` to the `TView.hostBindingOpCodes`.\n *\n * @param tView `TView` to which the `hostBindings` should be added.\n * @param tNode `TNode` the element which contains the directive\n * @param lView `LView` current `LView`\n * @param directiveIdx Directive index in view.\n * @param directiveVarsIdx Where will the directive's vars be stored\n * @param def `ComponentDef`/`DirectiveDef`, which contains the `hostVars`/`hostBindings` to add.\n */\nexport function registerHostBindingOpCodes(\n    tView: TView, tNode: TNode, lView: LView, directiveIdx: number, directiveVarsIdx: number,\n    def: ComponentDef<any>|DirectiveDef<any>): void {\n  ngDevMode && assertFirstCreatePass(tView);\n\n  const hostBindings = def.hostBindings;\n  if (hostBindings) {\n    let hostBindingOpCodes = tView.hostBindingOpCodes;\n    if (hostBindingOpCodes === null) {\n      hostBindingOpCodes = tView.hostBindingOpCodes = [] as any as HostBindingOpCodes;\n    }\n    const elementIndx = ~tNode.index;\n    if (lastSelectedElementIdx(hostBindingOpCodes) != elementIndx) {\n      // Conditionally add select element so that we are more efficient in execution.\n      // NOTE: this is strictly not necessary and it trades code size for runtime perf.\n      // (We could just always add it.)\n      hostBindingOpCodes.push(elementIndx);\n    }\n    hostBindingOpCodes.push(directiveIdx, directiveVarsIdx, hostBindings);\n  }\n}\n\n/**\n * Returns the last selected element index in the `HostBindingOpCodes`\n *\n * For perf reasons we don't need to update the selected element index in `HostBindingOpCodes` only\n * if it changes. This method returns the last index (or '0' if not found.)\n *\n * Selected element index are only the ones which are negative.\n */\nfunction lastSelectedElementIdx(hostBindingOpCodes: HostBindingOpCodes): number {\n  let i = hostBindingOpCodes.length;\n  while (i > 0) {\n    const value = hostBindingOpCodes[--i];\n    if (typeof value === 'number' && value < 0) {\n      return value;\n    }\n  }\n  return 0;\n}\n\n\n/**\n * Instantiate all the directives that were previously resolved on the current node.\n */\nfunction instantiateAllDirectives(\n    tView: TView, lView: LView, tNode: TDirectiveHostNode, native: RNode) {\n  const start = tNode.directiveStart;\n  const end = tNode.directiveEnd;\n  if (!tView.firstCreatePass) {\n    getOrCreateNodeInjectorForNode(tNode, lView);\n  }\n\n  attachPatchData(native, lView);\n\n  const initialInputs = tNode.initialInputs;\n  for (let i = start; i < end; i++) {\n    const def = tView.data[i] as DirectiveDef<any>;\n    const isComponent = isComponentDef(def);\n\n    if (isComponent) {\n      ngDevMode && assertTNodeType(tNode, TNodeType.AnyRNode);\n      addComponentLogic(lView, tNode as TElementNode, def as ComponentDef<any>);\n    }\n\n    const directive = getNodeInjectable(lView, tView, i, tNode);\n    attachPatchData(directive, lView);\n\n    if (initialInputs !== null) {\n      setInputsFromAttrs(lView, i - start, directive, def, tNode, initialInputs!);\n    }\n\n    if (isComponent) {\n      const componentView = getComponentLViewByIndex(tNode.index, lView);\n      componentView[CONTEXT] = directive;\n    }\n  }\n}\n\nfunction invokeDirectivesHostBindings(tView: TView, lView: LView, tNode: TNode) {\n  const start = tNode.directiveStart;\n  const end = tNode.directiveEnd;\n  const firstCreatePass = tView.firstCreatePass;\n  const elementIndex = tNode.index;\n  const currentDirectiveIndex = getCurrentDirectiveIndex();\n  try {\n    setSelectedIndex(elementIndex);\n    for (let dirIndex = start; dirIndex < end; dirIndex++) {\n      const def = tView.data[dirIndex] as DirectiveDef<unknown>;\n      const directive = lView[dirIndex];\n      setCurrentDirectiveIndex(dirIndex);\n      if (def.hostBindings !== null || def.hostVars !== 0 || def.hostAttrs !== null) {\n        invokeHostBindingsInCreationMode(def, directive);\n      }\n    }\n  } finally {\n    setSelectedIndex(-1);\n    setCurrentDirectiveIndex(currentDirectiveIndex);\n  }\n}\n\n/**\n * Invoke the host bindings in creation mode.\n *\n * @param def `DirectiveDef` which may contain the `hostBindings` function.\n * @param directive Instance of directive.\n */\nexport function invokeHostBindingsInCreationMode(def: DirectiveDef<any>, directive: any) {\n  if (def.hostBindings !== null) {\n    def.hostBindings!(RenderFlags.Create, directive);\n  }\n}\n\n/**\n * Matches the current node against all available selectors.\n * If a component is matched (at most one), it is returned in first position in the array.\n */\nfunction findDirectiveDefMatches(\n    tView: TView, viewData: LView,\n    tNode: TElementNode|TContainerNode|TElementContainerNode): DirectiveDef<any>[]|null {\n  ngDevMode && assertFirstCreatePass(tView);\n  ngDevMode && assertTNodeType(tNode, TNodeType.AnyRNode | TNodeType.AnyContainer);\n\n  const registry = tView.directiveRegistry;\n  let matches: any[]|null = null;\n  if (registry) {\n    for (let i = 0; i < registry.length; i++) {\n      const def = registry[i] as ComponentDef<any>| DirectiveDef<any>;\n      if (isNodeMatchingSelectorList(tNode, def.selectors!, /* isProjectionMode */ false)) {\n        matches || (matches = ngDevMode ? new MatchesArray() : []);\n        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, viewData), tView, def.type);\n\n        if (isComponentDef(def)) {\n          if (ngDevMode) {\n            assertTNodeType(\n                tNode, TNodeType.Element,\n                `\"${tNode.value}\" tags cannot be used as component hosts. ` +\n                    `Please use a different tag to activate the ${stringify(def.type)} component.`);\n\n            if (tNode.flags & TNodeFlags.isComponentHost) throwMultipleComponentError(tNode);\n          }\n          markAsComponentHost(tView, tNode);\n          // The component is always stored first with directives after.\n          matches.unshift(def);\n        } else {\n          matches.push(def);\n        }\n      }\n    }\n  }\n  return matches;\n}\n\n/**\n * Marks a given TNode as a component's host. This consists of:\n * - setting appropriate TNode flags;\n * - storing index of component's host element so it will be queued for view refresh during CD.\n */\nexport function markAsComponentHost(tView: TView, hostTNode: TNode): void {\n  ngDevMode && assertFirstCreatePass(tView);\n  hostTNode.flags |= TNodeFlags.isComponentHost;\n  (tView.components || (tView.components = ngDevMode ? new TViewComponents() : []))\n      .push(hostTNode.index);\n}\n\n\n/** Caches local names and their matching directive indices for query and template lookups. */\nfunction cacheMatchingLocalNames(\n    tNode: TNode, localRefs: string[]|null, exportsMap: {[key: string]: number}): void {\n  if (localRefs) {\n    const localNames: (string|number)[] = tNode.localNames = ngDevMode ? new TNodeLocalNames() : [];\n\n    // Local names must be stored in tNode in the same order that localRefs are defined\n    // in the template to ensure the data is loaded in the same slots as their refs\n    // in the template (for template queries).\n    for (let i = 0; i < localRefs.length; i += 2) {\n      const index = exportsMap[localRefs[i + 1]];\n      if (index == null)\n        throw new RuntimeError(\n            RuntimeErrorCode.EXPORT_NOT_FOUND, `Export of name '${localRefs[i + 1]}' not found!`);\n      localNames.push(localRefs[i], index);\n    }\n  }\n}\n\n/**\n * Builds up an export map as directives are created, so local refs can be quickly mapped\n * to their directive instances.\n */\nfunction saveNameToExportMap(\n    directiveIdx: number, def: DirectiveDef<any>|ComponentDef<any>,\n    exportsMap: {[key: string]: number}|null) {\n  if (exportsMap) {\n    if (def.exportAs) {\n      for (let i = 0; i < def.exportAs.length; i++) {\n        exportsMap[def.exportAs[i]] = directiveIdx;\n      }\n    }\n    if (isComponentDef(def)) exportsMap[''] = directiveIdx;\n  }\n}\n\n/**\n * Initializes the flags on the current node, setting all indices to the initial index,\n * the directive count to 0, and adding the isComponent flag.\n * @param index the initial index\n */\nexport function initTNodeFlags(tNode: TNode, index: number, numberOfDirectives: number) {\n  ngDevMode &&\n      assertNotEqual(\n          numberOfDirectives, tNode.directiveEnd - tNode.directiveStart,\n          'Reached the max number of directives');\n  tNode.flags |= TNodeFlags.isDirectiveHost;\n  // When the first directive is created on a node, save the index\n  tNode.directiveStart = index;\n  tNode.directiveEnd = index + numberOfDirectives;\n  tNode.providerIndexes = index;\n}\n\n/**\n * Setup directive for instantiation.\n *\n * We need to create a `NodeInjectorFactory` which is then inserted in both the `Blueprint` as well\n * as `LView`. `TView` gets the `DirectiveDef`.\n *\n * @param tView `TView`\n * @param tNode `TNode`\n * @param lView `LView`\n * @param directiveIndex Index where the directive will be stored in the Expando.\n * @param def `DirectiveDef`\n */\nfunction configureViewWithDirective<T>(\n    tView: TView, tNode: TNode, lView: LView, directiveIndex: number, def: DirectiveDef<T>): void {\n  ngDevMode &&\n      assertGreaterThanOrEqual(directiveIndex, HEADER_OFFSET, 'Must be in Expando section');\n  tView.data[directiveIndex] = def;\n  const directiveFactory =\n      def.factory || ((def as {factory: Function}).factory = getFactoryDef(def.type, true));\n  const nodeInjectorFactory = new NodeInjectorFactory(directiveFactory, isComponentDef(def), null);\n  tView.blueprint[directiveIndex] = nodeInjectorFactory;\n  lView[directiveIndex] = nodeInjectorFactory;\n\n  registerHostBindingOpCodes(\n      tView, tNode, lView, directiveIndex, allocExpando(tView, lView, def.hostVars, NO_CHANGE),\n      def);\n}\n\nfunction addComponentLogic<T>(lView: LView, hostTNode: TElementNode, def: ComponentDef<T>): void {\n  const native = getNativeByTNode(hostTNode, lView) as RElement;\n  const tView = getOrCreateTComponentView(def);\n\n  // Only component views should be added to the view tree directly. Embedded views are\n  // accessed through their containers because they may be removed / re-added later.\n  const rendererFactory = lView[RENDERER_FACTORY];\n  const componentView = addToViewTree(\n      lView,\n      createLView(\n          lView, tView, null, def.onPush ? LViewFlags.Dirty : LViewFlags.CheckAlways, native,\n          hostTNode as TElementNode, rendererFactory, rendererFactory.createRenderer(native, def),\n          null, null));\n\n  // Component view will always be created before any injected LContainers,\n  // so this is a regular element, wrap it with the component view\n  lView[hostTNode.index] = componentView;\n}\n\nexport function elementAttributeInternal(\n    tNode: TNode, lView: LView, name: string, value: any, sanitizer: SanitizerFn|null|undefined,\n    namespace: string|null|undefined) {\n  if (ngDevMode) {\n    assertNotSame(value, NO_CHANGE as any, 'Incoming value should never be NO_CHANGE.');\n    validateAgainstEventAttributes(name);\n    assertTNodeType(\n        tNode, TNodeType.Element,\n        `Attempted to set attribute \\`${name}\\` on a container node. ` +\n            `Host bindings are not valid on ng-container or ng-template.`);\n  }\n  const element = getNativeByTNode(tNode, lView) as RElement;\n  setElementAttribute(lView[RENDERER], element, namespace, tNode.value, name, value, sanitizer);\n}\n\nexport function setElementAttribute(\n    renderer: Renderer3, element: RElement, namespace: string|null|undefined, tagName: string|null,\n    name: string, value: any, sanitizer: SanitizerFn|null|undefined) {\n  if (value == null) {\n    ngDevMode && ngDevMode.rendererRemoveAttribute++;\n    isProceduralRenderer(renderer) ? renderer.removeAttribute(element, name, namespace) :\n                                     element.removeAttribute(name);\n  } else {\n    ngDevMode && ngDevMode.rendererSetAttribute++;\n    const strValue =\n        sanitizer == null ? renderStringify(value) : sanitizer(value, tagName || '', name);\n\n\n    if (isProceduralRenderer(renderer)) {\n      renderer.setAttribute(element, name, strValue, namespace);\n    } else {\n      namespace ? element.setAttributeNS(namespace, name, strValue) :\n                  element.setAttribute(name, strValue);\n    }\n  }\n}\n\n/**\n * Sets initial input properties on directive instances from attribute data\n *\n * @param lView Current LView that is being processed.\n * @param directiveIndex Index of the directive in directives array\n * @param instance Instance of the directive on which to set the initial inputs\n * @param def The directive def that contains the list of inputs\n * @param tNode The static data for this node\n */\nfunction setInputsFromAttrs<T>(\n    lView: LView, directiveIndex: number, instance: T, def: DirectiveDef<T>, tNode: TNode,\n    initialInputData: InitialInputData): void {\n  const initialInputs: InitialInputs|null = initialInputData![directiveIndex];\n  if (initialInputs !== null) {\n    const setInput = def.setInput;\n    for (let i = 0; i < initialInputs.length;) {\n      const publicName = initialInputs[i++];\n      const privateName = initialInputs[i++];\n      const value = initialInputs[i++];\n      if (setInput !== null) {\n        def.setInput!(instance, value, publicName, privateName);\n      } else {\n        (instance as any)[privateName] = value;\n      }\n      if (ngDevMode) {\n        const nativeElement = getNativeByTNode(tNode, lView) as RElement;\n        setNgReflectProperty(lView, nativeElement, tNode.type, privateName, value);\n      }\n    }\n  }\n}\n\n/**\n * Generates initialInputData for a node and stores it in the template's static storage\n * so subsequent template invocations don't have to recalculate it.\n *\n * initialInputData is an array containing values that need to be set as input properties\n * for directives on this node, but only once on creation. We need this array to support\n * the case where you set an @Input property of a directive using attribute-like syntax.\n * e.g. if you have a `name` @Input, you can set it once like this:\n *\n * <my-component name=\"Bess\"></my-component>\n *\n * @param inputs The list of inputs from the directive def\n * @param attrs The static attrs on this node\n */\nfunction generateInitialInputs(inputs: {[key: string]: string}, attrs: TAttributes): InitialInputs|\n    null {\n  let inputsToStore: InitialInputs|null = null;\n  let i = 0;\n  while (i < attrs.length) {\n    const attrName = attrs[i];\n    if (attrName === AttributeMarker.NamespaceURI) {\n      // We do not allow inputs on namespaced attributes.\n      i += 4;\n      continue;\n    } else if (attrName === AttributeMarker.ProjectAs) {\n      // Skip over the `ngProjectAs` value.\n      i += 2;\n      continue;\n    }\n\n    // If we hit any other attribute markers, we're done anyway. None of those are valid inputs.\n    if (typeof attrName === 'number') break;\n\n    if (inputs.hasOwnProperty(attrName as string)) {\n      if (inputsToStore === null) inputsToStore = [];\n      inputsToStore.push(attrName as string, inputs[attrName as string], attrs[i + 1] as string);\n    }\n\n    i += 2;\n  }\n  return inputsToStore;\n}\n\n//////////////////////////\n//// ViewContainer & View\n//////////////////////////\n\n// Not sure why I need to do `any` here but TS complains later.\nconst LContainerArray: any = ((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode()) &&\n    createNamedArrayType('LContainer');\n\n/**\n * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.\n *\n * @param hostNative The host element for the LContainer\n * @param hostTNode The host TNode for the LContainer\n * @param currentView The parent view of the LContainer\n * @param native The native comment element\n * @param isForViewContainerRef Optional a flag indicating the ViewContainerRef case\n * @returns LContainer\n */\nexport function createLContainer(\n    hostNative: RElement|RComment|LView, currentView: LView, native: RComment,\n    tNode: TNode): LContainer {\n  ngDevMode && assertLView(currentView);\n  ngDevMode && !isProceduralRenderer(currentView[RENDERER]) && assertDomNode(native);\n  // https://jsperf.com/array-literal-vs-new-array-really\n  const lContainer: LContainer = new (ngDevMode ? LContainerArray : Array)(\n      hostNative,   // host native\n      true,         // Boolean `true` in this position signifies that this is an `LContainer`\n      false,        // has transplanted views\n      currentView,  // parent\n      null,         // next\n      0,            // transplanted views to refresh count\n      tNode,        // t_host\n      native,       // native,\n      null,         // view refs\n      null,         // moved views\n  );\n  ngDevMode &&\n      assertEqual(\n          lContainer.length, CONTAINER_HEADER_OFFSET,\n          'Should allocate correct number of slots for LContainer header.');\n  ngDevMode && attachLContainerDebug(lContainer);\n  return lContainer;\n}\n\n/**\n * Goes over embedded views (ones created through ViewContainerRef APIs) and refreshes\n * them by executing an associated template function.\n */\nfunction refreshEmbeddedViews(lView: LView) {\n  for (let lContainer = getFirstLContainer(lView); lContainer !== null;\n       lContainer = getNextLContainer(lContainer)) {\n    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {\n      const embeddedLView = lContainer[i];\n      const embeddedTView = embeddedLView[TVIEW];\n      ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');\n      if (viewAttachedToChangeDetector(embeddedLView)) {\n        refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]!);\n      }\n    }\n  }\n}\n\n/**\n * Mark transplanted views as needing to be refreshed at their insertion points.\n *\n * @param lView The `LView` that may have transplanted views.\n */\nfunction markTransplantedViewsForRefresh(lView: LView) {\n  for (let lContainer = getFirstLContainer(lView); lContainer !== null;\n       lContainer = getNextLContainer(lContainer)) {\n    if (!lContainer[HAS_TRANSPLANTED_VIEWS]) continue;\n\n    const movedViews = lContainer[MOVED_VIEWS]!;\n    ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');\n    for (let i = 0; i < movedViews.length; i++) {\n      const movedLView = movedViews[i]!;\n      const insertionLContainer = movedLView[PARENT] as LContainer;\n      ngDevMode && assertLContainer(insertionLContainer);\n      // We don't want to increment the counter if the moved LView was already marked for\n      // refresh.\n      if ((movedLView[FLAGS] & LViewFlags.RefreshTransplantedView) === 0) {\n        updateTransplantedViewCount(insertionLContainer, 1);\n      }\n      // Note, it is possible that the `movedViews` is tracking views that are transplanted *and*\n      // those that aren't (declaration component === insertion component). In the latter case,\n      // it's fine to add the flag, as we will clear it immediately in\n      // `refreshEmbeddedViews` for the view currently being refreshed.\n      movedLView[FLAGS] |= LViewFlags.RefreshTransplantedView;\n    }\n  }\n}\n\n/////////////\n\n/**\n * Refreshes components by entering the component view and processing its bindings, queries, etc.\n *\n * @param componentHostIdx  Element index in LView[] (adjusted for HEADER_OFFSET)\n */\nfunction refreshComponent(hostLView: LView, componentHostIdx: number): void {\n  ngDevMode && assertEqual(isCreationMode(hostLView), false, 'Should be run in update mode');\n  const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);\n  // Only attached components that are CheckAlways or OnPush and dirty should be refreshed\n  if (viewAttachedToChangeDetector(componentView)) {\n    const tView = componentView[TVIEW];\n    if (componentView[FLAGS] & (LViewFlags.CheckAlways | LViewFlags.Dirty)) {\n      refreshView(tView, componentView, tView.template, componentView[CONTEXT]);\n    } else if (componentView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {\n      // Only attached components that are CheckAlways or OnPush and dirty should be refreshed\n      refreshContainsDirtyView(componentView);\n    }\n  }\n}\n\n/**\n * Refreshes all transplanted views marked with `LViewFlags.RefreshTransplantedView` that are\n * children or descendants of the given lView.\n *\n * @param lView The lView which contains descendant transplanted views that need to be refreshed.\n */\nfunction refreshContainsDirtyView(lView: LView) {\n  for (let lContainer = getFirstLContainer(lView); lContainer !== null;\n       lContainer = getNextLContainer(lContainer)) {\n    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {\n      const embeddedLView = lContainer[i];\n      if (embeddedLView[FLAGS] & LViewFlags.RefreshTransplantedView) {\n        const embeddedTView = embeddedLView[TVIEW];\n        ngDevMode && assertDefined(embeddedTView, 'TView must be allocated');\n        refreshView(embeddedTView, embeddedLView, embeddedTView.template, embeddedLView[CONTEXT]!);\n      } else if (embeddedLView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {\n        refreshContainsDirtyView(embeddedLView);\n      }\n    }\n  }\n\n  const tView = lView[TVIEW];\n  // Refresh child component views.\n  const components = tView.components;\n  if (components !== null) {\n    for (let i = 0; i < components.length; i++) {\n      const componentView = getComponentLViewByIndex(components[i], lView);\n      // Only attached components that are CheckAlways or OnPush and dirty should be refreshed\n      if (viewAttachedToChangeDetector(componentView) &&\n          componentView[TRANSPLANTED_VIEWS_TO_REFRESH] > 0) {\n        refreshContainsDirtyView(componentView);\n      }\n    }\n  }\n}\n\nfunction renderComponent(hostLView: LView, componentHostIdx: number) {\n  ngDevMode && assertEqual(isCreationMode(hostLView), true, 'Should be run in creation mode');\n  const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);\n  const componentTView = componentView[TVIEW];\n  syncViewWithBlueprint(componentTView, componentView);\n  renderView(componentTView, componentView, componentView[CONTEXT]);\n}\n\n/**\n * Syncs an LView instance with its blueprint if they have gotten out of sync.\n *\n * Typically, blueprints and their view instances should always be in sync, so the loop here\n * will be skipped. However, consider this case of two components side-by-side:\n *\n * App template:\n * ```\n * <comp></comp>\n * <comp></comp>\n * ```\n *\n * The following will happen:\n * 1. App template begins processing.\n * 2. First <comp> is matched as a component and its LView is created.\n * 3. Second <comp> is matched as a component and its LView is created.\n * 4. App template completes processing, so it's time to check child templates.\n * 5. First <comp> template is checked. It has a directive, so its def is pushed to blueprint.\n * 6. Second <comp> template is checked. Its blueprint has been updated by the first\n * <comp> template, but its LView was created before this update, so it is out of sync.\n *\n * Note that embedded views inside ngFor loops will never be out of sync because these views\n * are processed as soon as they are created.\n *\n * @param tView The `TView` that contains the blueprint for syncing\n * @param lView The view to sync\n */\nfunction syncViewWithBlueprint(tView: TView, lView: LView) {\n  for (let i = lView.length; i < tView.blueprint.length; i++) {\n    lView.push(tView.blueprint[i]);\n  }\n}\n\n/**\n * Adds LView or LContainer to the end of the current view tree.\n *\n * This structure will be used to traverse through nested views to remove listeners\n * and call onDestroy callbacks.\n *\n * @param lView The view where LView or LContainer should be added\n * @param adjustedHostIndex Index of the view's host node in LView[], adjusted for header\n * @param lViewOrLContainer The LView or LContainer to add to the view tree\n * @returns The state passed in\n */\nexport function addToViewTree<T extends LView|LContainer>(lView: LView, lViewOrLContainer: T): T {\n  // TODO(benlesh/misko): This implementation is incorrect, because it always adds the LContainer\n  // to the end of the queue, which means if the developer retrieves the LContainers from RNodes out\n  // of order, the change detection will run out of order, as the act of retrieving the the\n  // LContainer from the RNode is what adds it to the queue.\n  if (lView[CHILD_HEAD]) {\n    lView[CHILD_TAIL]![NEXT] = lViewOrLContainer;\n  } else {\n    lView[CHILD_HEAD] = lViewOrLContainer;\n  }\n  lView[CHILD_TAIL] = lViewOrLContainer;\n  return lViewOrLContainer;\n}\n\n///////////////////////////////\n//// Change detection\n///////////////////////////////\n\n\n/**\n * Marks current view and all ancestors dirty.\n *\n * Returns the root view because it is found as a byproduct of marking the view tree\n * dirty, and can be used by methods that consume markViewDirty() to easily schedule\n * change detection. Otherwise, such methods would need to traverse up the view tree\n * an additional time to get the root view and schedule a tick on it.\n *\n * @param lView The starting LView to mark dirty\n * @returns the root LView\n */\nexport function markViewDirty(lView: LView): LView|null {\n  while (lView) {\n    lView[FLAGS] |= LViewFlags.Dirty;\n    const parent = getLViewParent(lView);\n    // Stop traversing up as soon as you find a root view that wasn't attached to any container\n    if (isRootView(lView) && !parent) {\n      return lView;\n    }\n    // continue otherwise\n    lView = parent!;\n  }\n  return null;\n}\n\n\n/**\n * Used to schedule change detection on the whole application.\n *\n * Unlike `tick`, `scheduleTick` coalesces multiple calls into one change detection run.\n * It is usually called indirectly by calling `markDirty` when the view needs to be\n * re-rendered.\n *\n * Typically `scheduleTick` uses `requestAnimationFrame` to coalesce multiple\n * `scheduleTick` requests. The scheduling function can be overridden in\n * `renderComponent`'s `scheduler` option.\n */\nexport function scheduleTick(rootContext: RootContext, flags: RootContextFlags) {\n  const nothingScheduled = rootContext.flags === RootContextFlags.Empty;\n  if (nothingScheduled && rootContext.clean == _CLEAN_PROMISE) {\n    // https://github.com/angular/angular/issues/39296\n    // should only attach the flags when really scheduling a tick\n    rootContext.flags |= flags;\n    let res: null|((val: null) => void);\n    rootContext.clean = new Promise<null>((r) => res = r);\n    rootContext.scheduler(() => {\n      if (rootContext.flags & RootContextFlags.DetectChanges) {\n        rootContext.flags &= ~RootContextFlags.DetectChanges;\n        tickRootContext(rootContext);\n      }\n\n      if (rootContext.flags & RootContextFlags.FlushPlayers) {\n        rootContext.flags &= ~RootContextFlags.FlushPlayers;\n        const playerHandler = rootContext.playerHandler;\n        if (playerHandler) {\n          playerHandler.flushPlayers();\n        }\n      }\n\n      rootContext.clean = _CLEAN_PROMISE;\n      res!(null);\n    });\n  }\n}\n\nexport function tickRootContext(rootContext: RootContext) {\n  for (let i = 0; i < rootContext.components.length; i++) {\n    const rootComponent = rootContext.components[i];\n    const lView = readPatchedLView(rootComponent)!;\n    const tView = lView[TVIEW];\n    renderComponentOrTemplate(tView, lView, tView.template, rootComponent);\n  }\n}\n\nexport function detectChangesInternal<T>(tView: TView, lView: LView, context: T) {\n  const rendererFactory = lView[RENDERER_FACTORY];\n  if (rendererFactory.begin) rendererFactory.begin();\n  try {\n    refreshView(tView, lView, tView.template, context);\n  } catch (error) {\n    handleError(lView, error);\n    throw error;\n  } finally {\n    if (rendererFactory.end) rendererFactory.end();\n  }\n}\n\n/**\n * Synchronously perform change detection on a root view and its components.\n *\n * @param lView The view which the change detection should be performed on.\n */\nexport function detectChangesInRootView(lView: LView): void {\n  tickRootContext(lView[CONTEXT] as RootContext);\n}\n\nexport function checkNoChangesInternal<T>(tView: TView, view: LView, context: T) {\n  setIsInCheckNoChangesMode(true);\n  try {\n    detectChangesInternal(tView, view, context);\n  } finally {\n    setIsInCheckNoChangesMode(false);\n  }\n}\n\n/**\n * Checks the change detector on a root view and its components, and throws if any changes are\n * detected.\n *\n * This is used in development mode to verify that running change detection doesn't\n * introduce other changes.\n *\n * @param lView The view which the change detection should be checked on.\n */\nexport function checkNoChangesInRootView(lView: LView): void {\n  setIsInCheckNoChangesMode(true);\n  try {\n    detectChangesInRootView(lView);\n  } finally {\n    setIsInCheckNoChangesMode(false);\n  }\n}\n\nfunction executeViewQueryFn<T>(\n    flags: RenderFlags, viewQueryFn: ViewQueriesFunction<{}>, component: T): void {\n  ngDevMode && assertDefined(viewQueryFn, 'View queries function to execute must be defined.');\n  setCurrentQueryIndex(0);\n  viewQueryFn(flags, component);\n}\n\n\n///////////////////////////////\n//// Bindings & interpolations\n///////////////////////////////\n\n/**\n * Stores meta-data for a property binding to be used by TestBed's `DebugElement.properties`.\n *\n * In order to support TestBed's `DebugElement.properties` we need to save, for each binding:\n * - a bound property name;\n * - a static parts of interpolated strings;\n *\n * A given property metadata is saved at the binding's index in the `TView.data` (in other words, a\n * property binding metadata will be stored in `TView.data` at the same index as a bound value in\n * `LView`). Metadata are represented as `INTERPOLATION_DELIMITER`-delimited string with the\n * following format:\n * - `propertyName` for bound properties;\n * - `propertyName�prefix�interpolation_static_part1�..interpolation_static_partN�suffix` for\n * interpolated properties.\n *\n * @param tData `TData` where meta-data will be saved;\n * @param tNode `TNode` that is a target of the binding;\n * @param propertyName bound property name;\n * @param bindingIndex binding index in `LView`\n * @param interpolationParts static interpolation parts (for property interpolations)\n */\nexport function storePropertyBindingMetadata(\n    tData: TData, tNode: TNode, propertyName: string, bindingIndex: number,\n    ...interpolationParts: string[]) {\n  // Binding meta-data are stored only the first time a given property instruction is processed.\n  // Since we don't have a concept of the \"first update pass\" we need to check for presence of the\n  // binding meta-data to decide if one should be stored (or if was stored already).\n  if (tData[bindingIndex] === null) {\n    if (tNode.inputs == null || !tNode.inputs[propertyName]) {\n      const propBindingIdxs = tNode.propertyBindings || (tNode.propertyBindings = []);\n      propBindingIdxs.push(bindingIndex);\n      let bindingMetadata = propertyName;\n      if (interpolationParts.length > 0) {\n        bindingMetadata +=\n            INTERPOLATION_DELIMITER + interpolationParts.join(INTERPOLATION_DELIMITER);\n      }\n      tData[bindingIndex] = bindingMetadata;\n    }\n  }\n}\n\nexport const CLEAN_PROMISE = _CLEAN_PROMISE;\n\nexport function getOrCreateLViewCleanup(view: LView): any[] {\n  // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n  return view[CLEANUP] || (view[CLEANUP] = ngDevMode ? new LCleanup() : []);\n}\n\nexport function getOrCreateTViewCleanup(tView: TView): any[] {\n  return tView.cleanup || (tView.cleanup = ngDevMode ? new TCleanup() : []);\n}\n\n/**\n * There are cases where the sub component's renderer needs to be included\n * instead of the current renderer (see the componentSyntheticHost* instructions).\n */\nexport function loadComponentRenderer(\n    currentDef: DirectiveDef<any>|null, tNode: TNode, lView: LView): Renderer3 {\n  // TODO(FW-2043): the `currentDef` is null when host bindings are invoked while creating root\n  // component (see packages/core/src/render3/component.ts). This is not consistent with the process\n  // of creating inner components, when current directive index is available in the state. In order\n  // to avoid relying on current def being `null` (thus special-casing root component creation), the\n  // process of creating root component should be unified with the process of creating inner\n  // components.\n  if (currentDef === null || isComponentDef(currentDef)) {\n    lView = unwrapLView(lView[tNode.index])!;\n  }\n  return lView[RENDERER];\n}\n\n/** Handles an error thrown in an LView. */\nexport function handleError(lView: LView, error: any): void {\n  const injector = lView[INJECTOR];\n  const errorHandler = injector ? injector.get(ErrorHandler, null) : null;\n  errorHandler && errorHandler.handleError(error);\n}\n\n/**\n * Set the inputs of directives at the current node to corresponding value.\n *\n * @param tView The current TView\n * @param lView the `LView` which contains the directives.\n * @param inputs mapping between the public \"input\" name and privately-known,\n *        possibly minified, property names to write to.\n * @param value Value to set.\n */\nexport function setInputsForProperty(\n    tView: TView, lView: LView, inputs: PropertyAliasValue, publicName: string, value: any): void {\n  for (let i = 0; i < inputs.length;) {\n    const index = inputs[i++] as number;\n    const privateName = inputs[i++] as string;\n    const instance = lView[index];\n    ngDevMode && assertIndexInRange(lView, index);\n    const def = tView.data[index] as DirectiveDef<any>;\n    if (def.setInput !== null) {\n      def.setInput!(instance, value, publicName, privateName);\n    } else {\n      instance[privateName] = value;\n    }\n  }\n}\n\n/**\n * Updates a text binding at a given index in a given LView.\n */\nexport function textBindingInternal(lView: LView, index: number, value: string): void {\n  ngDevMode && assertString(value, 'Value should be a string');\n  ngDevMode && assertNotSame(value, NO_CHANGE as any, 'value should not be NO_CHANGE');\n  ngDevMode && assertIndexInRange(lView, index);\n  const element = getNativeByIndex(index, lView) as any as RText;\n  ngDevMode && assertDefined(element, 'native element should exist');\n  updateTextNode(lView[RENDERER], element, value);\n}\n"]}