@angular/core 9.0.3 → 9.0.7

package/bundles/core.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v9.0.3
+ * @license Angular v9.0.7
  * (c) 2010-2020 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -207,6 +207,26 @@
         return (mod && mod.__esModule) ? mod : { default: mod };
     }
 
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * Convince closure compiler that the wrapped function has no side-effects.
+     *
+     * Closure compiler always assumes that `toString` has no side-effects. We use this quirk to
+     * allow us to execute a function but have closure compiler mark the call as no-side-effects.
+     * It is important that the return value for the `noSideEffects` function be assigned
+     * to something which is retained otherwise the call to `noSideEffects` will be removed by closure
+     * compiler.
+     */
+    function noSideEffects(fn) {
+        return { toString: fn }.toString();
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -221,38 +241,40 @@
      * @suppress {globalThis}
      */
     function makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {
-        var metaCtor = makeMetadataCtor(props);
-        function DecoratorFactory() {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
+        return noSideEffects(function () {
+            var metaCtor = makeMetadataCtor(props);
+            function DecoratorFactory() {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                if (this instanceof DecoratorFactory) {
+                    metaCtor.call.apply(metaCtor, __spread([this], args));
+                    return this;
+                }
+                var annotationInstance = new ((_a = DecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
+                return function TypeDecorator(cls) {
+                    if (typeFn)
+                        typeFn.apply(void 0, __spread([cls], args));
+                    // Use of Object.defineProperty is important since it creates non-enumerable property which
+                    // prevents the property is copied during subclassing.
+                    var annotations = cls.hasOwnProperty(ANNOTATIONS) ?
+                        cls[ANNOTATIONS] :
+                        Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];
+                    annotations.push(annotationInstance);
+                    if (additionalProcessing)
+                        additionalProcessing(cls);
+                    return cls;
+                };
             }
-            if (this instanceof DecoratorFactory) {
-                metaCtor.call.apply(metaCtor, __spread([this], args));
-                return this;
+            if (parentClass) {
+                DecoratorFactory.prototype = Object.create(parentClass.prototype);
             }
-            var annotationInstance = new ((_a = DecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
-            return function TypeDecorator(cls) {
-                if (typeFn)
-                    typeFn.apply(void 0, __spread([cls], args));
-                // Use of Object.defineProperty is important since it creates non-enumerable property which
-                // prevents the property is copied during subclassing.
-                var annotations = cls.hasOwnProperty(ANNOTATIONS) ?
-                    cls[ANNOTATIONS] :
-                    Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];
-                annotations.push(annotationInstance);
-                if (additionalProcessing)
-                    additionalProcessing(cls);
-                return cls;
-            };
-        }
-        if (parentClass) {
-            DecoratorFactory.prototype = Object.create(parentClass.prototype);
-        }
-        DecoratorFactory.prototype.ngMetadataName = name;
-        DecoratorFactory.annotationCls = DecoratorFactory;
-        return DecoratorFactory;
+            DecoratorFactory.prototype.ngMetadataName = name;
+            DecoratorFactory.annotationCls = DecoratorFactory;
+            return DecoratorFactory;
+        });
     }
     function makeMetadataCtor(props) {
         return function ctor() {
@@ -269,75 +291,79 @@
         };
     }
     function makeParamDecorator(name, props, parentClass) {
-        var metaCtor = makeMetadataCtor(props);
-        function ParamDecoratorFactory() {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (this instanceof ParamDecoratorFactory) {
-                metaCtor.apply(this, args);
-                return this;
-            }
-            var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
-            ParamDecorator.annotation = annotationInstance;
-            return ParamDecorator;
-            function ParamDecorator(cls, unusedKey, index) {
-                // Use of Object.defineProperty is important since it creates non-enumerable property which
-                // prevents the property is copied during subclassing.
-                var parameters = cls.hasOwnProperty(PARAMETERS) ?
-                    cls[PARAMETERS] :
-                    Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];
-                // there might be gaps if some in between parameters do not have annotations.
-                // we pad with nulls.
-                while (parameters.length <= index) {
-                    parameters.push(null);
+        return noSideEffects(function () {
+            var metaCtor = makeMetadataCtor(props);
+            function ParamDecoratorFactory() {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                if (this instanceof ParamDecoratorFactory) {
+                    metaCtor.apply(this, args);
+                    return this;
+                }
+                var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
+                ParamDecorator.annotation = annotationInstance;
+                return ParamDecorator;
+                function ParamDecorator(cls, unusedKey, index) {
+                    // Use of Object.defineProperty is important since it creates non-enumerable property which
+                    // prevents the property is copied during subclassing.
+                    var parameters = cls.hasOwnProperty(PARAMETERS) ?
+                        cls[PARAMETERS] :
+                        Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];
+                    // there might be gaps if some in between parameters do not have annotations.
+                    // we pad with nulls.
+                    while (parameters.length <= index) {
+                        parameters.push(null);
+                    }
+                    (parameters[index] = parameters[index] || []).push(annotationInstance);
+                    return cls;
                 }
-                (parameters[index] = parameters[index] || []).push(annotationInstance);
-                return cls;
             }
-        }
-        if (parentClass) {
-            ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
-        }
-        ParamDecoratorFactory.prototype.ngMetadataName = name;
-        ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
-        return ParamDecoratorFactory;
+            if (parentClass) {
+                ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
+            }
+            ParamDecoratorFactory.prototype.ngMetadataName = name;
+            ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
+            return ParamDecoratorFactory;
+        });
     }
     function makePropDecorator(name, props, parentClass, additionalProcessing) {
-        var metaCtor = makeMetadataCtor(props);
-        function PropDecoratorFactory() {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (this instanceof PropDecoratorFactory) {
-                metaCtor.apply(this, args);
-                return this;
-            }
-            var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
-            function PropDecorator(target, name) {
-                var constructor = target.constructor;
-                // Use of Object.defineProperty is important since it creates non-enumerable property which
-                // prevents the property is copied during subclassing.
-                var meta = constructor.hasOwnProperty(PROP_METADATA) ?
-                    constructor[PROP_METADATA] :
-                    Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];
-                meta[name] = meta.hasOwnProperty(name) && meta[name] || [];
-                meta[name].unshift(decoratorInstance);
-                if (additionalProcessing)
-                    additionalProcessing.apply(void 0, __spread([target, name], args));
-            }
-            return PropDecorator;
-        }
-        if (parentClass) {
-            PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
-        }
-        PropDecoratorFactory.prototype.ngMetadataName = name;
-        PropDecoratorFactory.annotationCls = PropDecoratorFactory;
-        return PropDecoratorFactory;
+        return noSideEffects(function () {
+            var metaCtor = makeMetadataCtor(props);
+            function PropDecoratorFactory() {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                if (this instanceof PropDecoratorFactory) {
+                    metaCtor.apply(this, args);
+                    return this;
+                }
+                var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();
+                function PropDecorator(target, name) {
+                    var constructor = target.constructor;
+                    // Use of Object.defineProperty is important since it creates non-enumerable property which
+                    // prevents the property is copied during subclassing.
+                    var meta = constructor.hasOwnProperty(PROP_METADATA) ?
+                        constructor[PROP_METADATA] :
+                        Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];
+                    meta[name] = meta.hasOwnProperty(name) && meta[name] || [];
+                    meta[name].unshift(decoratorInstance);
+                    if (additionalProcessing)
+                        additionalProcessing.apply(void 0, __spread([target, name], args));
+                }
+                return PropDecorator;
+            }
+            if (parentClass) {
+                PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
+            }
+            PropDecoratorFactory.prototype.ngMetadataName = name;
+            PropDecoratorFactory.annotationCls = PropDecoratorFactory;
+            return PropDecoratorFactory;
+        });
     }
 
     /**
@@ -1266,8 +1292,6 @@
         }
     }
     function throwError(msg, actual, expected, comparison) {
-        // tslint:disable-next-line
-        debugger; // Left intentionally for better debugger experience.
         throw new Error("ASSERTION ERROR: " + msg +
             (comparison == null ? '' : " [Expected=> " + expected + " " + comparison + " " + actual + " <=Actual]"));
     }
@@ -1695,26 +1719,6 @@
         ViewEncapsulation[ViewEncapsulation["ShadowDom"] = 3] = "ShadowDom";
     })(exports.ViewEncapsulation || (exports.ViewEncapsulation = {}));
 
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    /**
-     * Convince closure compiler that the wrapped function has no side-effects.
-     *
-     * Closure compiler always assumes that `toString` has no side-effects. We use this quirk to
-     * allow us to execute a function but have closure compiler mark the call as no-side-effects.
-     * It is important that the return value for the `noSideEffects` function be assigned
-     * to something which is retained otherwise the call to `noSideEffects` will be removed by closure
-     * compiler.
-     */
-    function noSideEffects(fn) {
-        return '' + { toString: fn };
-    }
-
     /**
     * @license
     * Copyright Google Inc. All Rights Reserved.
@@ -1765,55 +1769,55 @@
      * @codeGenApi
      */
     function ɵɵdefineComponent(componentDefinition) {
-        // Initialize ngDevMode. This must be the first statement in ɵɵdefineComponent.
-        // See the `initNgDevMode` docstring for more information.
-        (typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode();
-        var type = componentDefinition.type;
-        var typePrototype = type.prototype;
-        var declaredInputs = {};
-        var def = {
-            type: type,
-            providersResolver: null,
-            decls: componentDefinition.decls,
-            vars: componentDefinition.vars,
-            factory: null,
-            template: componentDefinition.template || null,
-            consts: componentDefinition.consts || null,
-            ngContentSelectors: componentDefinition.ngContentSelectors,
-            hostBindings: componentDefinition.hostBindings || null,
-            hostVars: componentDefinition.hostVars || 0,
-            hostAttrs: componentDefinition.hostAttrs || null,
-            contentQueries: componentDefinition.contentQueries || null,
-            declaredInputs: declaredInputs,
-            inputs: null,
-            outputs: null,
-            exportAs: componentDefinition.exportAs || null,
-            onChanges: null,
-            onInit: typePrototype.ngOnInit || null,
-            doCheck: typePrototype.ngDoCheck || null,
-            afterContentInit: typePrototype.ngAfterContentInit || null,
-            afterContentChecked: typePrototype.ngAfterContentChecked || null,
-            afterViewInit: typePrototype.ngAfterViewInit || null,
-            afterViewChecked: typePrototype.ngAfterViewChecked || null,
-            onDestroy: typePrototype.ngOnDestroy || null,
-            onPush: componentDefinition.changeDetection === exports.ChangeDetectionStrategy.OnPush,
-            directiveDefs: null,
-            pipeDefs: null,
-            selectors: componentDefinition.selectors || EMPTY_ARRAY,
-            viewQuery: componentDefinition.viewQuery || null,
-            features: componentDefinition.features || null,
-            data: componentDefinition.data || {},
-            // TODO(misko): convert ViewEncapsulation into const enum so that it can be used directly in the
-            // next line. Also `None` should be 0 not 2.
-            encapsulation: componentDefinition.encapsulation || exports.ViewEncapsulation.Emulated,
-            id: 'c',
-            styles: componentDefinition.styles || EMPTY_ARRAY,
-            _: null,
-            setInput: null,
-            schemas: componentDefinition.schemas || null,
-            tView: null,
-        };
-        def._ = noSideEffects(function () {
+        return noSideEffects(function () {
+            // Initialize ngDevMode. This must be the first statement in ɵɵdefineComponent.
+            // See the `initNgDevMode` docstring for more information.
+            (typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode();
+            var type = componentDefinition.type;
+            var typePrototype = type.prototype;
+            var declaredInputs = {};
+            var def = {
+                type: type,
+                providersResolver: null,
+                decls: componentDefinition.decls,
+                vars: componentDefinition.vars,
+                factory: null,
+                template: componentDefinition.template || null,
+                consts: componentDefinition.consts || null,
+                ngContentSelectors: componentDefinition.ngContentSelectors,
+                hostBindings: componentDefinition.hostBindings || null,
+                hostVars: componentDefinition.hostVars || 0,
+                hostAttrs: componentDefinition.hostAttrs || null,
+                contentQueries: componentDefinition.contentQueries || null,
+                declaredInputs: declaredInputs,
+                inputs: null,
+                outputs: null,
+                exportAs: componentDefinition.exportAs || null,
+                onChanges: null,
+                onInit: typePrototype.ngOnInit || null,
+                doCheck: typePrototype.ngDoCheck || null,
+                afterContentInit: typePrototype.ngAfterContentInit || null,
+                afterContentChecked: typePrototype.ngAfterContentChecked || null,
+                afterViewInit: typePrototype.ngAfterViewInit || null,
+                afterViewChecked: typePrototype.ngAfterViewChecked || null,
+                onDestroy: typePrototype.ngOnDestroy || null,
+                onPush: componentDefinition.changeDetection === exports.ChangeDetectionStrategy.OnPush,
+                directiveDefs: null,
+                pipeDefs: null,
+                selectors: componentDefinition.selectors || EMPTY_ARRAY,
+                viewQuery: componentDefinition.viewQuery || null,
+                features: componentDefinition.features || null,
+                data: componentDefinition.data || {},
+                // TODO(misko): convert ViewEncapsulation into const enum so that it can be used directly in
+                // the next line. Also `None` should be 0 not 2.
+                encapsulation: componentDefinition.encapsulation || exports.ViewEncapsulation.Emulated,
+                id: 'c',
+                styles: componentDefinition.styles || EMPTY_ARRAY,
+                _: null,
+                setInput: null,
+                schemas: componentDefinition.schemas || null,
+                tView: null,
+            };
             var directiveTypes = componentDefinition.directives;
             var feature = componentDefinition.features;
             var pipeTypes = componentDefinition.pipes;
@@ -1828,8 +1832,8 @@
             def.pipeDefs = pipeTypes ?
                 function () { return (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef); } :
                 null;
+            return def;
         });
-        return def;
     }
     /**
      * @codeGenApi
@@ -2156,6 +2160,8 @@
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    // [Assert functions do not constraint type when they are guarded by a truthy
+    // expression.](https://github.com/microsoft/TypeScript/issues/37295)
     function assertTNodeForLView(tNode, lView) {
         tNode.hasOwnProperty('tView_') && assertEqual(tNode.tView_, lView[TVIEW], 'This TNode does not belong to this LView.');
     }
@@ -2223,6 +2229,266 @@
     var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
     var MATH_ML_NAMESPACE = 'http://www.w3.org/1998/MathML/';
 
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * This property will be monkey-patched on elements, components and directives
+     */
+    var MONKEY_PATCH_KEY_NAME = '__ngContext__';
+
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * Most of the use of `document` in Angular is from within the DI system so it is possible to simply
+     * inject the `DOCUMENT` token and are done.
+     *
+     * Ivy is special because it does not rely upon the DI and must get hold of the document some other
+     * way.
+     *
+     * The solution is to define `getDocument()` and `setDocument()` top-level functions for ivy.
+     * Wherever ivy needs the global document, it calls `getDocument()` instead.
+     *
+     * When running ivy outside of a browser environment, it is necessary to call `setDocument()` to
+     * tell ivy what the global `document` is.
+     *
+     * Angular does this for us in each of the standard platforms (`Browser`, `Server`, and `WebWorker`)
+     * by calling `setDocument()` when providing the `DOCUMENT` token.
+     */
+    var DOCUMENT = undefined;
+    /**
+     * Tell ivy what the `document` is for this platform.
+     *
+     * It is only necessary to call this if the current platform is not a browser.
+     *
+     * @param document The object representing the global `document` in this environment.
+     */
+    function setDocument(document) {
+        DOCUMENT = document;
+    }
+    /**
+     * Access the object that represents the `document` for this platform.
+     *
+     * Ivy calls this whenever it needs to access the `document` object.
+     * For example to create the renderer or to do sanitization.
+     */
+    function getDocument() {
+        if (DOCUMENT !== undefined) {
+            return DOCUMENT;
+        }
+        else if (typeof document !== 'undefined') {
+            return document;
+        }
+        // No "document" can be found. This should only happen if we are running ivy outside Angular and
+        // the current platform is not a browser. Since this is not a supported scenario at the moment
+        // this should not happen in Angular apps.
+        // Once we support running ivy outside of Angular we will need to publish `setDocument()` as a
+        // public API. Meanwhile we just return `undefined` and let the application fail.
+        return undefined;
+    }
+
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    // TODO: cleanup once the code is merged in angular/angular
+    var RendererStyleFlags3;
+    (function (RendererStyleFlags3) {
+        RendererStyleFlags3[RendererStyleFlags3["Important"] = 1] = "Important";
+        RendererStyleFlags3[RendererStyleFlags3["DashCase"] = 2] = "DashCase";
+    })(RendererStyleFlags3 || (RendererStyleFlags3 = {}));
+    /** Returns whether the `renderer` is a `ProceduralRenderer3` */
+    function isProceduralRenderer(renderer) {
+        return !!(renderer.listen);
+    }
+    var ɵ0$2 = function (hostElement, rendererType) { return getDocument(); };
+    var domRendererFactory3 = {
+        createRenderer: ɵ0$2
+    };
+    // Note: This hack is necessary so we don't erroneously get a circular dependency
+    // failure based on types.
+    var unusedValueExportToPlacateAjd$2 = 1;
+
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
+     * in same location in `LView`. This is because we don't want to pre-allocate space for it
+     * because the storage is sparse. This file contains utilities for dealing with such data types.
+     *
+     * How do we know what is stored at a given location in `LView`.
+     * - `Array.isArray(value) === false` => `RNode` (The normal storage value)
+     * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.
+     *   - `typeof value[TYPE] === 'object'` => `LView`
+     *      - This happens when we have a component at a given location
+     *   - `typeof value[TYPE] === true` => `LContainer`
+     *      - This happens when we have `LContainer` binding at a given location.
+     *
+     *
+     * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.
+     */
+    /**
+     * Returns `RNode`.
+     * @param value wrapped value of `RNode`, `LView`, `LContainer`
+     */
+    function unwrapRNode(value) {
+        while (Array.isArray(value)) {
+            value = value[HOST];
+        }
+        return value;
+    }
+    /**
+     * Returns `LView` or `null` if not found.
+     * @param value wrapped value of `RNode`, `LView`, `LContainer`
+     */
+    function unwrapLView(value) {
+        while (Array.isArray(value)) {
+            // This check is same as `isLView()` but we don't call at as we don't want to call
+            // `Array.isArray()` twice and give JITer more work for inlining.
+            if (typeof value[TYPE] === 'object')
+                return value;
+            value = value[HOST];
+        }
+        return null;
+    }
+    /**
+     * Returns `LContainer` or `null` if not found.
+     * @param value wrapped value of `RNode`, `LView`, `LContainer`
+     */
+    function unwrapLContainer(value) {
+        while (Array.isArray(value)) {
+            // This check is same as `isLContainer()` but we don't call at as we don't want to call
+            // `Array.isArray()` twice and give JITer more work for inlining.
+            if (value[TYPE] === true)
+                return value;
+            value = value[HOST];
+        }
+        return null;
+    }
+    /**
+     * Retrieves an element value from the provided `viewData`, by unwrapping
+     * from any containers, component views, or style contexts.
+     */
+    function getNativeByIndex(index, lView) {
+        return unwrapRNode(lView[index + HEADER_OFFSET]);
+    }
+    /**
+     * Retrieve an `RNode` for a given `TNode` and `LView`.
+     *
+     * This function guarantees in dev mode to retrieve a non-null `RNode`.
+     *
+     * @param tNode
+     * @param lView
+     */
+    function getNativeByTNode(tNode, lView) {
+        ngDevMode && assertTNodeForLView(tNode, lView);
+        ngDevMode && assertDataInRange(lView, tNode.index);
+        var node = unwrapRNode(lView[tNode.index]);
+        ngDevMode && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
+        return node;
+    }
+    /**
+     * Retrieve an `RNode` or `null` for a given `TNode` and `LView`.
+     *
+     * Some `TNode`s don't have associated `RNode`s. For example `Projection`
+     *
+     * @param tNode
+     * @param lView
+     */
+    function getNativeByTNodeOrNull(tNode, lView) {
+        var index = tNode.index;
+        if (index !== -1) {
+            ngDevMode && assertTNodeForLView(tNode, lView);
+            var node = unwrapRNode(lView[index]);
+            ngDevMode && node !== null && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
+            return node;
+        }
+        return null;
+    }
+    function getTNode(tView, index) {
+        ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
+        ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
+        return tView.data[index + HEADER_OFFSET];
+    }
+    /** Retrieves a value from any `LView` or `TData`. */
+    function load(view, index) {
+        ngDevMode && assertDataInRange(view, index + HEADER_OFFSET);
+        return view[index + HEADER_OFFSET];
+    }
+    function getComponentLViewByIndex(nodeIndex, hostView) {
+        // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
+        ngDevMode && assertDataInRange(hostView, nodeIndex);
+        var slotValue = hostView[nodeIndex];
+        var lView = isLView(slotValue) ? slotValue : slotValue[HOST];
+        return lView;
+    }
+    /**
+     * Returns the monkey-patch value data present on the target (which could be
+     * a component, directive or a DOM node).
+     */
+    function readPatchedData(target) {
+        ngDevMode && assertDefined(target, 'Target expected');
+        return target[MONKEY_PATCH_KEY_NAME] || null;
+    }
+    function readPatchedLView(target) {
+        var value = readPatchedData(target);
+        if (value) {
+            return Array.isArray(value) ? value : value.lView;
+        }
+        return null;
+    }
+    /** Checks whether a given view is in creation mode */
+    function isCreationMode(view) {
+        return (view[FLAGS] & 4 /* CreationMode */) === 4 /* CreationMode */;
+    }
+    /**
+     * Returns a boolean for whether the view is attached to the change detection tree.
+     *
+     * Note: This determines whether a view should be checked, not whether it's inserted
+     * into a container. For that, you'll want `viewAttachedToContainer` below.
+     */
+    function viewAttachedToChangeDetector(view) {
+        return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;
+    }
+    /** Returns a boolean for whether the view is attached to a container. */
+    function viewAttachedToContainer(view) {
+        return isLContainer(view[PARENT]);
+    }
+    /** Returns a constant from `TConstants` instance. */
+    function getConstant(consts, index) {
+        return consts === null || index == null ? null : consts[index];
+    }
+    /**
+     * Resets the pre-order hook flags of the view.
+     * @param lView the LView on which the flags are reset
+     */
+    function resetPreOrderHookFlags(lView) {
+        lView[PREORDER_HOOK_FLAGS] = 0;
+    }
+    function getLContainerActiveIndex(lContainer) {
+        return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
+    }
+    function setLContainerActiveIndex(lContainer, index) {
+        lContainer[ACTIVE_INDEX] = index << 1 /* SHIFT */;
+    }
+
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -2553,6 +2819,13 @@
     function setSelectedIndex(index) {
         instructionState.lFrame.selectedIndex = index;
     }
+    /**
+     * Gets the `tNode` that represents currently selected element.
+     */
+    function getSelectedTNode() {
+        var lFrame = instructionState.lFrame;
+        return getTNode(lFrame.tView, lFrame.selectedIndex);
+    }
     /**
      * Sets the namespace used to create elements to `'http://www.w3.org/2000/svg'` in global state.
      *
@@ -2946,7 +3219,7 @@
     }
     // Note: This hack is necessary so we don't erroneously get a circular dependency
     // failure based on types.
-    var unusedValueExportToPlacateAjd$2 = 1;
+    var unusedValueExportToPlacateAjd$3 = 1;
 
     /**
      * @license
@@ -2978,91 +3251,11 @@
         if (type == 2 /* View */)
             return 'View';
         if (type == 3 /* Element */)
-            return 'Element';
-        if (type == 4 /* ElementContainer */)
-            return 'ElementContainer';
-        return '<unknown>';
-    }
-
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    /**
-     * Most of the use of `document` in Angular is from within the DI system so it is possible to simply
-     * inject the `DOCUMENT` token and are done.
-     *
-     * Ivy is special because it does not rely upon the DI and must get hold of the document some other
-     * way.
-     *
-     * The solution is to define `getDocument()` and `setDocument()` top-level functions for ivy.
-     * Wherever ivy needs the global document, it calls `getDocument()` instead.
-     *
-     * When running ivy outside of a browser environment, it is necessary to call `setDocument()` to
-     * tell ivy what the global `document` is.
-     *
-     * Angular does this for us in each of the standard platforms (`Browser`, `Server`, and `WebWorker`)
-     * by calling `setDocument()` when providing the `DOCUMENT` token.
-     */
-    var DOCUMENT = undefined;
-    /**
-     * Tell ivy what the `document` is for this platform.
-     *
-     * It is only necessary to call this if the current platform is not a browser.
-     *
-     * @param document The object representing the global `document` in this environment.
-     */
-    function setDocument(document) {
-        DOCUMENT = document;
-    }
-    /**
-     * Access the object that represents the `document` for this platform.
-     *
-     * Ivy calls this whenever it needs to access the `document` object.
-     * For example to create the renderer or to do sanitization.
-     */
-    function getDocument() {
-        if (DOCUMENT !== undefined) {
-            return DOCUMENT;
-        }
-        else if (typeof document !== 'undefined') {
-            return document;
-        }
-        // No "document" can be found. This should only happen if we are running ivy outside Angular and
-        // the current platform is not a browser. Since this is not a supported scenario at the moment
-        // this should not happen in Angular apps.
-        // Once we support running ivy outside of Angular we will need to publish `setDocument()` as a
-        // public API. Meanwhile we just return `undefined` and let the application fail.
-        return undefined;
-    }
-
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    // TODO: cleanup once the code is merged in angular/angular
-    var RendererStyleFlags3;
-    (function (RendererStyleFlags3) {
-        RendererStyleFlags3[RendererStyleFlags3["Important"] = 1] = "Important";
-        RendererStyleFlags3[RendererStyleFlags3["DashCase"] = 2] = "DashCase";
-    })(RendererStyleFlags3 || (RendererStyleFlags3 = {}));
-    /** Returns whether the `renderer` is a `ProceduralRenderer3` */
-    function isProceduralRenderer(renderer) {
-        return !!(renderer.listen);
+            return 'Element';
+        if (type == 4 /* ElementContainer */)
+            return 'ElementContainer';
+        return '<unknown>';
     }
-    var ɵ0$2 = function (hostElement, rendererType) { return getDocument(); };
-    var domRendererFactory3 = {
-        createRenderer: ɵ0$2
-    };
-    // Note: This hack is necessary so we don't erroneously get a circular dependency
-    // failure based on types.
-    var unusedValueExportToPlacateAjd$3 = 1;
 
     /**
      * Assigns all attribute values to the provided element via the inferred renderer.
@@ -3975,18 +4168,20 @@
      * @codeGenApi
      */
     function ɵɵgetInheritedFactory(type) {
-        var proto = Object.getPrototypeOf(type.prototype).constructor;
-        var factory = proto[NG_FACTORY_DEF] || ɵɵgetFactoryOf(proto);
-        if (factory !== null) {
-            return factory;
-        }
-        else {
-            // There is no factory defined. Either this was improper usage of inheritance
-            // (no Angular decorator on the superclass) or there is no constructor at all
-            // in the inheritance chain. Since the two cases cannot be distinguished, the
-            // latter has to be assumed.
-            return function (t) { return new t(); };
-        }
+        return noSideEffects(function () {
+            var proto = Object.getPrototypeOf(type.prototype).constructor;
+            var factory = proto[NG_FACTORY_DEF] || ɵɵgetFactoryOf(proto);
+            if (factory !== null) {
+                return factory;
+            }
+            else {
+                // There is no factory defined. Either this was improper usage of inheritance
+                // (no Angular decorator on the superclass) or there is no constructor at all
+                // in the inheritance chain. Since the two cases cannot be distinguished, the
+                // latter has to be assumed.
+                return function (t) { return new t(); };
+            }
+        });
     }
 
     /**
@@ -5194,186 +5389,6 @@
         }
     }
 
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    /**
-     * This property will be monkey-patched on elements, components and directives
-     */
-    var MONKEY_PATCH_KEY_NAME = '__ngContext__';
-
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * Use of this source code is governed by an MIT-style license that can be
-     * found in the LICENSE file at https://angular.io/license
-     */
-    /**
-     * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
-     * in same location in `LView`. This is because we don't want to pre-allocate space for it
-     * because the storage is sparse. This file contains utilities for dealing with such data types.
-     *
-     * How do we know what is stored at a given location in `LView`.
-     * - `Array.isArray(value) === false` => `RNode` (The normal storage value)
-     * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.
-     *   - `typeof value[TYPE] === 'object'` => `LView`
-     *      - This happens when we have a component at a given location
-     *   - `typeof value[TYPE] === true` => `LContainer`
-     *      - This happens when we have `LContainer` binding at a given location.
-     *
-     *
-     * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.
-     */
-    /**
-     * Returns `RNode`.
-     * @param value wrapped value of `RNode`, `LView`, `LContainer`
-     */
-    function unwrapRNode(value) {
-        while (Array.isArray(value)) {
-            value = value[HOST];
-        }
-        return value;
-    }
-    /**
-     * Returns `LView` or `null` if not found.
-     * @param value wrapped value of `RNode`, `LView`, `LContainer`
-     */
-    function unwrapLView(value) {
-        while (Array.isArray(value)) {
-            // This check is same as `isLView()` but we don't call at as we don't want to call
-            // `Array.isArray()` twice and give JITer more work for inlining.
-            if (typeof value[TYPE] === 'object')
-                return value;
-            value = value[HOST];
-        }
-        return null;
-    }
-    /**
-     * Returns `LContainer` or `null` if not found.
-     * @param value wrapped value of `RNode`, `LView`, `LContainer`
-     */
-    function unwrapLContainer(value) {
-        while (Array.isArray(value)) {
-            // This check is same as `isLContainer()` but we don't call at as we don't want to call
-            // `Array.isArray()` twice and give JITer more work for inlining.
-            if (value[TYPE] === true)
-                return value;
-            value = value[HOST];
-        }
-        return null;
-    }
-    /**
-     * Retrieves an element value from the provided `viewData`, by unwrapping
-     * from any containers, component views, or style contexts.
-     */
-    function getNativeByIndex(index, lView) {
-        return unwrapRNode(lView[index + HEADER_OFFSET]);
-    }
-    /**
-     * Retrieve an `RNode` for a given `TNode` and `LView`.
-     *
-     * This function guarantees in dev mode to retrieve a non-null `RNode`.
-     *
-     * @param tNode
-     * @param lView
-     */
-    function getNativeByTNode(tNode, lView) {
-        ngDevMode && assertTNodeForLView(tNode, lView);
-        ngDevMode && assertDataInRange(lView, tNode.index);
-        var node = unwrapRNode(lView[tNode.index]);
-        ngDevMode && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
-        return node;
-    }
-    /**
-     * Retrieve an `RNode` or `null` for a given `TNode` and `LView`.
-     *
-     * Some `TNode`s don't have associated `RNode`s. For example `Projection`
-     *
-     * @param tNode
-     * @param lView
-     */
-    function getNativeByTNodeOrNull(tNode, lView) {
-        var index = tNode.index;
-        if (index !== -1) {
-            ngDevMode && assertTNodeForLView(tNode, lView);
-            var node = unwrapRNode(lView[index]);
-            ngDevMode && node !== null && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
-            return node;
-        }
-        return null;
-    }
-    function getTNode(tView, index) {
-        ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
-        ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
-        return tView.data[index + HEADER_OFFSET];
-    }
-    /** Retrieves a value from any `LView` or `TData`. */
-    function load(view, index) {
-        ngDevMode && assertDataInRange(view, index + HEADER_OFFSET);
-        return view[index + HEADER_OFFSET];
-    }
-    function getComponentLViewByIndex(nodeIndex, hostView) {
-        // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
-        ngDevMode && assertDataInRange(hostView, nodeIndex);
-        var slotValue = hostView[nodeIndex];
-        var lView = isLView(slotValue) ? slotValue : slotValue[HOST];
-        return lView;
-    }
-    /**
-     * Returns the monkey-patch value data present on the target (which could be
-     * a component, directive or a DOM node).
-     */
-    function readPatchedData(target) {
-        ngDevMode && assertDefined(target, 'Target expected');
-        return target[MONKEY_PATCH_KEY_NAME] || null;
-    }
-    function readPatchedLView(target) {
-        var value = readPatchedData(target);
-        if (value) {
-            return Array.isArray(value) ? value : value.lView;
-        }
-        return null;
-    }
-    /** Checks whether a given view is in creation mode */
-    function isCreationMode(view) {
-        return (view[FLAGS] & 4 /* CreationMode */) === 4 /* CreationMode */;
-    }
-    /**
-     * Returns a boolean for whether the view is attached to the change detection tree.
-     *
-     * Note: This determines whether a view should be checked, not whether it's inserted
-     * into a container. For that, you'll want `viewAttachedToContainer` below.
-     */
-    function viewAttachedToChangeDetector(view) {
-        return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;
-    }
-    /** Returns a boolean for whether the view is attached to a container. */
-    function viewAttachedToContainer(view) {
-        return isLContainer(view[PARENT]);
-    }
-    /** Returns a constant from `TConstants` instance. */
-    function getConstant(consts, index) {
-        return consts === null || index == null ? null : consts[index];
-    }
-    /**
-     * Resets the pre-order hook flags of the view.
-     * @param lView the LView on which the flags are reset
-     */
-    function resetPreOrderHookFlags(lView) {
-        lView[PREORDER_HOOK_FLAGS] = 0;
-    }
-    function getLContainerActiveIndex(lContainer) {
-        return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
-    }
-    function setLContainerActiveIndex(lContainer, index) {
-        lContainer[ACTIVE_INDEX] = index << 1 /* SHIFT */;
-    }
-
     /**
      * @license
      * Copyright Google Inc. All Rights Reserved.
@@ -5691,8 +5706,6 @@
         }
         // TODO: include debug context, see `viewDebugError` function in
         // `packages/core/src/view/errors.ts` for reference.
-        // tslint:disable-next-line
-        debugger; // Left intentionally for better debugger experience.
         throw new Error(msg);
     }
     function constructDetailsForInterpolation(lView, rootIndex, expressionIndex, meta, changedValue) {
@@ -8045,7 +8058,7 @@
             outputsStore = generatePropertyAliases(directiveDef.outputs, i, outputsStore);
         }
         if (inputsStore !== null) {
-            if (inputsStore.hasOwnProperty('class') || inputsStore.hasOwnProperty('className')) {
+            if (inputsStore.hasOwnProperty('class')) {
                 tNode.flags |= 16 /* hasClassInput */;
             }
             if (inputsStore.hasOwnProperty('style')) {
@@ -8081,16 +8094,15 @@
             return 'tabIndex';
         return name;
     }
-    function elementPropertyInternal(tView, lView, index, propName, value, sanitizer, nativeOnly, loadRendererFn) {
+    function elementPropertyInternal(tView, tNode, lView, propName, value, renderer, sanitizer, nativeOnly) {
         ngDevMode && assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
-        var element = getNativeByIndex(index, lView);
-        var tNode = getTNode(tView, index);
+        var element = getNativeByTNode(tNode, lView);
         var inputData = tNode.inputs;
         var dataValue;
         if (!nativeOnly && inputData != null && (dataValue = inputData[propName])) {
             setInputsForProperty(tView, lView, dataValue, propName, value);
             if (isComponentHost(tNode))
-                markDirtyIfOnPush(lView, index + HEADER_OFFSET);
+                markDirtyIfOnPush(lView, tNode.index);
             if (ngDevMode) {
                 setNgReflectProperties(lView, element, tNode.type, dataValue, value);
             }
@@ -8106,7 +8118,6 @@
                 }
                 ngDevMode.rendererSetProperty++;
             }
-            var renderer = loadRendererFn ? loadRendererFn(tNode, lView) : lView[RENDERER];
             // 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.tagName || '', propName) : value;
@@ -8516,10 +8527,10 @@
         // so this is a regular element, wrap it with the component view
         lView[hostTNode.index] = componentView;
     }
-    function elementAttributeInternal(index, name, value, tView, lView, sanitizer, namespace) {
+    function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
         ngDevMode && assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
         ngDevMode && validateAgainstEventAttributes(name);
-        var element = getNativeByIndex(index, lView);
+        var element = getNativeByTNode(tNode, lView);
         var renderer = lView[RENDERER];
         if (value == null) {
             ngDevMode && ngDevMode.rendererRemoveAttribute++;
@@ -8528,7 +8539,6 @@
         }
         else {
             ngDevMode && ngDevMode.rendererSetAttribute++;
-            var tNode = getTNode(tView, index);
             var strValue = sanitizer == null ? renderStringify(value) : sanitizer(value, tNode.tagName || '', name);
             if (isProceduralRenderer(renderer)) {
                 renderer.setAttribute(element, name, strValue, namespace);
@@ -8935,12 +8945,12 @@
      * interpolated properties.
      *
      * @param tData `TData` where meta-data will be saved;
-     * @param nodeIndex index of a `TNode` that is a target of the binding;
+     * @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)
      */
-    function storePropertyBindingMetadata(tData, nodeIndex, propertyName, bindingIndex) {
+    function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex) {
         var interpolationParts = [];
         for (var _i = 4; _i < arguments.length; _i++) {
             interpolationParts[_i - 4] = arguments[_i];
@@ -8949,7 +8959,6 @@
         // 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) {
-            var tNode = tData[nodeIndex + HEADER_OFFSET];
             if (tNode.inputs == null || !tNode.inputs[propertyName]) {
                 var propBindingIdxs = tNode.propertyBindings || (tNode.propertyBindings = []);
                 propBindingIdxs.push(bindingIndex);
@@ -9028,7 +9037,7 @@
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var unusedValueToPlacateAjd$1 = unusedValueExportToPlacateAjd$1 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$3 + unusedValueExportToPlacateAjd;
+    var unusedValueToPlacateAjd$1 = unusedValueExportToPlacateAjd$1 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$2 + unusedValueExportToPlacateAjd;
     function getLContainer(tNode, embeddedView) {
         ngDevMode && assertLView(embeddedView);
         var container = embeddedView[PARENT];
@@ -11116,7 +11125,7 @@
                             typeArgumentCount: metadata.typeArgumentCount,
                             deps: reflectDependencies(type),
                             injectFn: 'inject',
-                            target: compiler.R3FactoryTarget.Pipe
+                            target: compiler.R3FactoryTarget.Injectable
                         });
                     }
                     return ngFactoryDef;
@@ -11306,8 +11315,19 @@
     function createInjector(defType, parent, additionalProviders, name) {
         if (parent === void 0) { parent = null; }
         if (additionalProviders === void 0) { additionalProviders = null; }
-        parent = parent || getNullInjector();
-        return new R3Injector(defType, additionalProviders, parent, name);
+        var injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
+        injector._resolveInjectorDefTypes();
+        return injector;
+    }
+    /**
+     * Creates a new injector without eagerly resolving its injector types. Can be used in places
+     * where resolving the injector types immediately can lead to an infinite loop. The injector types
+     * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
+     */
+    function createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name) {
+        if (parent === void 0) { parent = null; }
+        if (additionalProviders === void 0) { additionalProviders = null; }
+        return new R3Injector(defType, additionalProviders, parent || getNullInjector(), name);
     }
     var R3Injector = /** @class */ (function () {
         function R3Injector(def, additionalProviders, parent, source) {
@@ -11341,8 +11361,6 @@
             // any injectable scoped to APP_ROOT_SCOPE.
             var record = this.records.get(INJECTOR_SCOPE);
             this.scope = record != null ? record.value : null;
-            // Eagerly instantiate the InjectorType classes themselves.
-            this.injectorDefTypes.forEach(function (defType) { return _this.get(defType); });
             // Source name, used for debugging
             this.source = source || (typeof def === 'object' ? null : stringify(def));
         }
@@ -11437,6 +11455,11 @@
                 setCurrentInjector(previousInjector);
             }
         };
+        /** @internal */
+        R3Injector.prototype._resolveInjectorDefTypes = function () {
+            var _this = this;
+            this.injectorDefTypes.forEach(function (defType) { return _this.get(defType); });
+        };
         R3Injector.prototype.toString = function () {
             var tokens = [], records = this.records;
             records.forEach(function (v, token) { return tokens.push(stringify(token)); });
@@ -13489,10 +13512,10 @@
         var lView = getLView();
         var bindingIndex = nextBindingIndex();
         if (bindingUpdated(lView, bindingIndex, value)) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementAttributeInternal(nodeIndex, name, value, tView, lView, sanitizer, namespace);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + name, bindingIndex);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, 'attr.' + name, bindingIndex);
         }
         return ɵɵattribute;
     }
@@ -13662,11 +13685,10 @@
         var lView = getLView();
         var interpolatedValue = interpolation1(lView, prefix, v0, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
             ngDevMode &&
-                storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 1, prefix, suffix);
+                storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 1, prefix, suffix);
         }
         return ɵɵattributeInterpolate1;
     }
@@ -13700,11 +13722,10 @@
         var lView = getLView();
         var interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
             ngDevMode &&
-                storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 2, prefix, i0, suffix);
+                storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 2, prefix, i0, suffix);
         }
         return ɵɵattributeInterpolate2;
     }
@@ -13741,10 +13762,9 @@
         var lView = getLView();
         var interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 3, prefix, i0, i1, suffix);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
+            ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 3, prefix, i0, i1, suffix);
         }
         return ɵɵattributeInterpolate3;
     }
@@ -13783,10 +13803,9 @@
         var lView = getLView();
         var interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 4, prefix, i0, i1, i2, suffix);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
+            ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 4, prefix, i0, i1, i2, suffix);
         }
         return ɵɵattributeInterpolate4;
     }
@@ -13827,10 +13846,9 @@
         var lView = getLView();
         var interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 5, prefix, i0, i1, i2, i3, suffix);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
+            ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 5, prefix, i0, i1, i2, i3, suffix);
         }
         return ɵɵattributeInterpolate5;
     }
@@ -13873,10 +13891,9 @@
         var lView = getLView();
         var interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 6, prefix, i0, i1, i2, i3, i4, suffix);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
+            ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 6, prefix, i0, i1, i2, i3, i4, suffix);
         }
         return ɵɵattributeInterpolate6;
     }
@@ -13921,10 +13938,9 @@
         var lView = getLView();
         var interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 7, prefix, i0, i1, i2, i3, i4, i5, suffix);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
+            ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 7, prefix, i0, i1, i2, i3, i4, i5, suffix);
         }
         return ɵɵattributeInterpolate7;
     }
@@ -13971,10 +13987,9 @@
         var lView = getLView();
         var interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
-            var tView = getTView();
-            elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 8, prefix, i0, i1, i2, i3, i4, i5, i6, suffix);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
+            ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 8, prefix, i0, i1, i2, i3, i4, i5, i6, suffix);
         }
         return ɵɵattributeInterpolate8;
     }
@@ -14008,15 +14023,14 @@
         var lView = getLView();
         var interpolated = interpolationV(lView, values);
         if (interpolated !== NO_CHANGE) {
-            var tView = getTView();
-            var nodeIndex = getSelectedIndex();
-            elementAttributeInternal(nodeIndex, attrName, interpolated, tView, lView, sanitizer, namespace);
+            var tNode = getSelectedTNode();
+            elementAttributeInternal(tNode, lView, attrName, interpolated, sanitizer, namespace);
             if (ngDevMode) {
                 var interpolationInBetween = [values[0]]; // prefix
                 for (var i = 2; i < values.length; i += 2) {
                     interpolationInBetween.push(values[i]);
                 }
-                storePropertyBindingMetadata.apply(void 0, __spread([tView.data, nodeIndex, 'attr.' + attrName,
+                storePropertyBindingMetadata.apply(void 0, __spread([getTView().data, tNode, 'attr.' + attrName,
                     getBindingIndex() - interpolationInBetween.length + 1], interpolationInBetween));
             }
         }
@@ -14338,10 +14352,10 @@
         var lView = getLView();
         var bindingIndex = nextBindingIndex();
         if (bindingUpdated(lView, bindingIndex, value)) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, value, sanitizer);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, bindingIndex);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, value, lView[RENDERER], sanitizer, false);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
         }
         return ɵɵproperty;
     }
@@ -14353,8 +14367,7 @@
         var inputs = tNode.inputs;
         var property = isClassBased ? 'class' : 'style';
         // We support both 'class' and `className` hence the fallback.
-        var stylingInputs = inputs[property] || (isClassBased && inputs['className']);
-        setInputsForProperty(tView, lView, stylingInputs, property, value);
+        setInputsForProperty(tView, lView, inputs[property], property, value);
     }
 
     /**
@@ -15230,10 +15243,10 @@
         var lView = getLView();
         var interpolatedValue = interpolation1(lView, prefix, v0, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 1, prefix, suffix);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 1, prefix, suffix);
         }
         return ɵɵpropertyInterpolate1;
     }
@@ -15271,10 +15284,10 @@
         var lView = getLView();
         var interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 2, prefix, i0, suffix);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 2, prefix, i0, suffix);
         }
         return ɵɵpropertyInterpolate2;
     }
@@ -15315,11 +15328,10 @@
         var lView = getLView();
         var interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-            ngDevMode &&
-                storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 3, prefix, i0, i1, suffix);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 3, prefix, i0, i1, suffix);
         }
         return ɵɵpropertyInterpolate3;
     }
@@ -15362,11 +15374,11 @@
         var lView = getLView();
         var interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
             ngDevMode &&
-                storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 4, prefix, i0, i1, i2, suffix);
+                storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 4, prefix, i0, i1, i2, suffix);
         }
         return ɵɵpropertyInterpolate4;
     }
@@ -15411,11 +15423,11 @@
         var lView = getLView();
         var interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
             ngDevMode &&
-                storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 5, prefix, i0, i1, i2, i3, suffix);
+                storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 5, prefix, i0, i1, i2, i3, suffix);
         }
         return ɵɵpropertyInterpolate5;
     }
@@ -15462,10 +15474,11 @@
         var lView = getLView();
         var interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 6, prefix, i0, i1, i2, i3, i4, suffix);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
+            ngDevMode &&
+                storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 6, prefix, i0, i1, i2, i3, i4, suffix);
         }
         return ɵɵpropertyInterpolate6;
     }
@@ -15514,10 +15527,10 @@
         var lView = getLView();
         var interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 7, prefix, i0, i1, i2, i3, i4, i5, suffix);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 7, prefix, i0, i1, i2, i3, i4, i5, suffix);
         }
         return ɵɵpropertyInterpolate7;
     }
@@ -15568,10 +15581,10 @@
         var lView = getLView();
         var interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 8, prefix, i0, i1, i2, i3, i4, i5, i6, suffix);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 8, prefix, i0, i1, i2, i3, i4, i5, i6, suffix);
         }
         return ɵɵpropertyInterpolate8;
     }
@@ -15609,15 +15622,15 @@
         var lView = getLView();
         var interpolatedValue = interpolationV(lView, values);
         if (interpolatedValue !== NO_CHANGE) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
             if (ngDevMode) {
                 var interpolationInBetween = [values[0]]; // prefix
                 for (var i = 2; i < values.length; i += 2) {
                     interpolationInBetween.push(values[i]);
                 }
-                storePropertyBindingMetadata.apply(void 0, __spread([tView.data, nodeIndex, propName, getBindingIndex() - interpolationInBetween.length + 1], interpolationInBetween));
+                storePropertyBindingMetadata.apply(void 0, __spread([tView.data, tNode, propName, getBindingIndex() - interpolationInBetween.length + 1], interpolationInBetween));
             }
         }
         return ɵɵpropertyInterpolateV;
@@ -18465,10 +18478,10 @@
         var lView = getLView();
         var bindingIndex = nextBindingIndex();
         if (bindingUpdated(lView, bindingIndex, value)) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, value, sanitizer, true);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, bindingIndex);
+            var tNode = getSelectedTNode();
+            elementPropertyInternal(tView, tNode, lView, propName, value, lView[RENDERER], sanitizer, true);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
         }
         return ɵɵhostProperty;
     }
@@ -18497,10 +18510,11 @@
         var lView = getLView();
         var bindingIndex = nextBindingIndex();
         if (bindingUpdated(lView, bindingIndex, value)) {
-            var nodeIndex = getSelectedIndex();
             var tView = getTView();
-            elementPropertyInternal(tView, lView, nodeIndex, propName, value, sanitizer, true, loadComponentRenderer);
-            ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, bindingIndex);
+            var tNode = getSelectedTNode();
+            var renderer = loadComponentRenderer(tNode, lView);
+            elementPropertyInternal(tView, tNode, lView, propName, value, renderer, sanitizer, true);
+            ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
         }
         return ɵɵupdateSyntheticHostBinding;
     }
@@ -19455,24 +19469,23 @@
      * static ɵcmp = defineComponent({
      *   ...
      *   inputs: {name: 'publicName'},
-     *   features: [NgOnChangesFeature()]
+     *   features: [NgOnChangesFeature]
      * });
      * ```
      *
      * @codeGenApi
      */
-    function ɵɵNgOnChangesFeature() {
-        // This option ensures that the ngOnChanges lifecycle hook will be inherited
-        // from superclasses (in InheritDefinitionFeature).
-        NgOnChangesFeatureImpl.ngInherit = true;
-        return NgOnChangesFeatureImpl;
-    }
-    function NgOnChangesFeatureImpl(definition) {
+    function ɵɵNgOnChangesFeature(definition) {
         if (definition.type.prototype.ngOnChanges) {
             definition.setInput = ngOnChangesSetInput;
             definition.onChanges = wrapOnChanges();
         }
     }
+    // This option ensures that the ngOnChanges lifecycle hook will be inherited
+    // from superclasses (in InheritDefinitionFeature).
+    /** @nocollapse */
+    // tslint:disable-next-line:no-toplevel-property-access
+    ɵɵNgOnChangesFeature.ngInherit = true;
     function wrapOnChanges() {
         return function wrapOnChangesHook_inPreviousChangesStorage() {
             var simpleChangesStore = getSimpleChangesStore(this);
@@ -20056,7 +20069,7 @@
     /**
      * @publicApi
      */
-    var VERSION = new Version('9.0.3');
+    var VERSION = new Version('9.0.7');
 
     /**
      * @license
@@ -23750,11 +23763,17 @@
                 for (var j = 0; j < parts.length; j++) {
                     if (j & 1) {
                         // Odd indexes are ICU expressions
+                        var icuExpression = parts[j];
+                        // Verify that ICU expression has the right shape. Translations might contain invalid
+                        // constructions (while original messages were correct), so ICU parsing at runtime may not
+                        // succeed (thus `icuExpression` remains a string).
+                        if (typeof icuExpression !== 'object') {
+                            throw new Error("Unable to parse ICU expression in \"" + templateTranslation + "\" message.");
+                        }
                         // Create the comment node that will anchor the ICU expression
                         var icuNodeIndex = startIndex + i18nVarsCount++;
                         createOpCodes.push(COMMENT_MARKER, ngDevMode ? "ICU " + icuNodeIndex : '', icuNodeIndex, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
                         // Update codes for the ICU expression
-                        var icuExpression = parts[j];
                         var mask = getBindingMask(icuExpression);
                         icuStart(icuExpressions, icuExpression, icuNodeIndex, icuNodeIndex);
                         // Since this is recursive, the last TIcu that was pushed is the one we want
@@ -23976,7 +23995,8 @@
             }
             // Check if an element has any local refs and skip them
             var tNode = getTNode(tView, index);
-            if (tNode && (tNode.type === 3 /* Element */ || tNode.type === 4 /* ElementContainer */) &&
+            if (tNode && (tNode.type === 0 /* Container */ || tNode.type === 3 /* Element */ ||
+                tNode.type === 4 /* ElementContainer */) &&
                 tNode.localNames !== null) {
                 // Divide by 2 to get the number of local refs,
                 // since they are stored as an array that also includes directive indexes,
@@ -24059,7 +24079,7 @@
                         var attrValue = createOpCodes[++i];
                         // This code is used for ICU expressions only, since we don't support
                         // directives/components in ICUs, we don't need to worry about inputs here
-                        elementAttributeInternal(elementNodeIndex, attrName, attrValue, tView, lView);
+                        elementAttributeInternal(getTNode(tView, elementNodeIndex), lView, attrName, attrValue, null, null);
                         break;
                     default:
                         throw new Error("Unable to determine the type of mutate operation for \"" + opCode + "\"");
@@ -24129,7 +24149,7 @@
                                 case 1 /* Attr */:
                                     var propName = updateOpCodes[++j];
                                     var sanitizeFn = updateOpCodes[++j];
-                                    elementPropertyInternal(tView, lView, nodeIndex, propName, value, sanitizeFn);
+                                    elementPropertyInternal(tView, getTNode(tView, nodeIndex), lView, propName, value, lView[RENDERER], sanitizeFn, false);
                                     break;
                                 case 0 /* Text */:
                                     textBindingInternal(lView, nodeIndex, value);
@@ -24283,7 +24303,7 @@
                         // Set attributes for Elements only, for other types (like ElementContainer),
                         // only set inputs below
                         if (tNode.type === 3 /* Element */) {
-                            elementAttributeInternal(previousElementIndex, attrName, value, tView, lView);
+                            elementAttributeInternal(tNode, lView, attrName, value, null, null);
                         }
                         // Check if that attribute is a directive input
                         var dataValue = tNode.inputs !== null && tNode.inputs[attrName];
@@ -24671,10 +24691,14 @@
             var ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);
             ngLocaleIdDef && setLocaleId(ngLocaleIdDef);
             _this._bootstrapComponents = maybeUnwrapFn(ngModuleDef.bootstrap);
-            _this._r3Injector = createInjector(ngModuleType, _parent, [
+            _this._r3Injector = createInjectorWithoutInjectorInstances(ngModuleType, _parent, [
                 { provide: NgModuleRef, useValue: _this },
                 { provide: ComponentFactoryResolver, useValue: _this.componentFactoryResolver }
             ], stringify(ngModuleType));
+            // We need to resolve the injector types separately from the injector creation, because
+            // the module might be trying to use this ref in its contructor for DI which will cause a
+            // circular error that will eventually error out, because the injector isn't created yet.
+            _this._r3Injector._resolveInjectorDefTypes();
             _this.instance = _this.get(ngModuleType);
             return _this;
         }
@@ -25031,6 +25055,18 @@
     function ɵɵpureFunctionV(slotOffset, pureFn, exps, thisArg) {
         return pureFunctionVInternal(getLView(), getBindingRoot(), slotOffset, pureFn, exps, thisArg);
     }
+    /**
+     * Results of a pure function invocation are stored in LView in a dedicated slot that is initialized
+     * to NO_CHANGE. In rare situations a pure pipe might throw an exception on the very first
+     * invocation and not produce any valid results. In this case LView would keep holding the NO_CHANGE
+     * value. The NO_CHANGE is not something that we can use in expressions / bindings thus we convert
+     * it to `undefined`.
+     */
+    function getPureFunctionReturnValue(lView, returnValueIndex) {
+        ngDevMode && assertDataInRange(lView, returnValueIndex);
+        var lastReturnValue = lView[returnValueIndex];
+        return lastReturnValue === NO_CHANGE ? undefined : lastReturnValue;
+    }
     /**
      * If the value of the provided exp has changed, calls the pure function to return
      * an updated value. Or if the value has not changed, returns cached value.
@@ -25047,7 +25083,7 @@
         var bindingIndex = bindingRoot + slotOffset;
         return bindingUpdated(lView, bindingIndex, exp) ?
             updateBinding(lView, bindingIndex + 1, thisArg ? pureFn.call(thisArg, exp) : pureFn(exp)) :
-            getBinding(lView, bindingIndex + 1);
+            getPureFunctionReturnValue(lView, bindingIndex + 1);
     }
     /**
      * If the value of any provided exp has changed, calls the pure function to return
@@ -25066,7 +25102,7 @@
         var bindingIndex = bindingRoot + slotOffset;
         return bindingUpdated2(lView, bindingIndex, exp1, exp2) ?
             updateBinding(lView, bindingIndex + 2, thisArg ? pureFn.call(thisArg, exp1, exp2) : pureFn(exp1, exp2)) :
-            getBinding(lView, bindingIndex + 2);
+            getPureFunctionReturnValue(lView, bindingIndex + 2);
     }
     /**
      * If the value of any provided exp has changed, calls the pure function to return
@@ -25086,7 +25122,7 @@
         var bindingIndex = bindingRoot + slotOffset;
         return bindingUpdated3(lView, bindingIndex, exp1, exp2, exp3) ?
             updateBinding(lView, bindingIndex + 3, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3) : pureFn(exp1, exp2, exp3)) :
-            getBinding(lView, bindingIndex + 3);
+            getPureFunctionReturnValue(lView, bindingIndex + 3);
     }
     /**
      * If the value of any provided exp has changed, calls the pure function to return
@@ -25108,7 +25144,7 @@
         var bindingIndex = bindingRoot + slotOffset;
         return bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) ?
             updateBinding(lView, bindingIndex + 4, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4) : pureFn(exp1, exp2, exp3, exp4)) :
-            getBinding(lView, bindingIndex + 4);
+            getPureFunctionReturnValue(lView, bindingIndex + 4);
     }
     /**
      * pureFunction instruction that can support any number of bindings.
@@ -25132,7 +25168,7 @@
             bindingUpdated(lView, bindingIndex++, exps[i]) && (different = true);
         }
         return different ? updateBinding(lView, bindingIndex, pureFn.apply(thisArg, exps)) :
-            getBinding(lView, bindingIndex);
+            getPureFunctionReturnValue(lView, bindingIndex);
     }
 
     /**
@@ -25586,7 +25622,7 @@
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var unusedValueToPlacateAjd$2 = unusedValueExportToPlacateAjd$7 + unusedValueExportToPlacateAjd$2 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$8;
+    var unusedValueToPlacateAjd$2 = unusedValueExportToPlacateAjd$7 + unusedValueExportToPlacateAjd$3 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$8;
     var LQuery_ = /** @class */ (function () {
         function LQuery_(queryList) {
             this.queryList = queryList;
@@ -25897,9 +25933,7 @@
             for (var i = 0; i < tQueryMatches.length; i += 2) {
                 var tNodeIdx = tQueryMatches[i];
                 if (tNodeIdx > 0) {
-                    var viewResult = lViewResults[i / 2];
-                    ngDevMode && assertDefined(viewResult, 'materialized query result should be defined');
-                    result.push(viewResult);
+                    result.push(lViewResults[i / 2]);
                 }
                 else {
                     var childQueryIndex = tQueryMatches[i + 1];
@@ -26663,6 +26697,17 @@
                 pipes: new Set(),
             },
         };
+        maybeUnwrapFn(def.imports).forEach(function (imported) {
+            var importedType = imported;
+            if (!isNgModule(importedType)) {
+                throw new Error("Importing " + importedType.name + " which does not have a \u0275mod property");
+            }
+            // When this module imports another, the imported module's exported directives and pipes are
+            // added to the compilation scope of this module.
+            var importedScope = transitiveScopesFor(importedType);
+            importedScope.exported.directives.forEach(function (entry) { return scopes.compilation.directives.add(entry); });
+            importedScope.exported.pipes.forEach(function (entry) { return scopes.compilation.pipes.add(entry); });
+        });
         maybeUnwrapFn(def.declarations).forEach(function (declared) {
             var declaredWithDefs = declared;
             if (getPipeDef(declaredWithDefs)) {
@@ -26675,17 +26720,6 @@
                 scopes.compilation.directives.add(declared);
             }
         });
-        maybeUnwrapFn(def.imports).forEach(function (imported) {
-            var importedType = imported;
-            if (!isNgModule(importedType)) {
-                throw new Error("Importing " + importedType.name + " which does not have a \u0275mod property");
-            }
-            // When this module imports another, the imported module's exported directives and pipes are
-            // added to the compilation scope of this module.
-            var importedScope = transitiveScopesFor(importedType);
-            importedScope.exported.directives.forEach(function (entry) { return scopes.compilation.directives.add(entry); });
-            importedScope.exported.pipes.forEach(function (entry) { return scopes.compilation.pipes.add(entry); });
-        });
         maybeUnwrapFn(def.exports).forEach(function (exported) {
             var exportedType = exported;
             // Either the type is a module, a pipe, or a component/directive (which may not have a
@@ -32478,7 +32512,7 @@
     exports.ɵangular_packages_core_core_bl = makeParamDecorator;
     exports.ɵangular_packages_core_core_bm = makePropDecorator;
     exports.ɵangular_packages_core_core_bn = getClosureSafeProperty;
-    exports.ɵangular_packages_core_core_bp = noSideEffects;
+    exports.ɵangular_packages_core_core_bo = noSideEffects;
     exports.ɵangular_packages_core_core_bq = getRootContext;
     exports.ɵangular_packages_core_core_c = NullInjector;
     exports.ɵangular_packages_core_core_d = ReflectiveInjector_;