@angular/core 9.0.3 → 9.0.7

package/fesm2015/core.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
  */
@@ -7,6 +7,26 @@
 import { Subject, Subscription, Observable, merge as merge$1 } from 'rxjs';
 import { share } from 'rxjs/operators';
 
+/**
+ * @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.
@@ -21,33 +41,35 @@ const PROP_METADATA = '__prop__metadata__';
  * @suppress {globalThis}
  */
 function makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {
-    const metaCtor = makeMetadataCtor(props);
-    function DecoratorFactory(...args) {
-        if (this instanceof DecoratorFactory) {
-            metaCtor.call(this, ...args);
-            return this;
+    return noSideEffects(() => {
+        const metaCtor = makeMetadataCtor(props);
+        function DecoratorFactory(...args) {
+            if (this instanceof DecoratorFactory) {
+                metaCtor.call(this, ...args);
+                return this;
+            }
+            const annotationInstance = new DecoratorFactory(...args);
+            return function TypeDecorator(cls) {
+                if (typeFn)
+                    typeFn(cls, ...args);
+                // Use of Object.defineProperty is important since it creates non-enumerable property which
+                // prevents the property is copied during subclassing.
+                const annotations = cls.hasOwnProperty(ANNOTATIONS) ?
+                    cls[ANNOTATIONS] :
+                    Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];
+                annotations.push(annotationInstance);
+                if (additionalProcessing)
+                    additionalProcessing(cls);
+                return cls;
+            };
         }
-        const annotationInstance = new DecoratorFactory(...args);
-        return function TypeDecorator(cls) {
-            if (typeFn)
-                typeFn(cls, ...args);
-            // Use of Object.defineProperty is important since it creates non-enumerable property which
-            // prevents the property is copied during subclassing.
-            const 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;
+        if (parentClass) {
+            DecoratorFactory.prototype = Object.create(parentClass.prototype);
+        }
+        DecoratorFactory.prototype.ngMetadataName = name;
+        DecoratorFactory.annotationCls = DecoratorFactory;
+        return DecoratorFactory;
+    });
 }
 function makeMetadataCtor(props) {
     return function ctor(...args) {
@@ -60,65 +82,69 @@ function makeMetadataCtor(props) {
     };
 }
 function makeParamDecorator(name, props, parentClass) {
-    const metaCtor = makeMetadataCtor(props);
-    function ParamDecoratorFactory(...args) {
-        if (this instanceof ParamDecoratorFactory) {
-            metaCtor.apply(this, args);
-            return this;
-        }
-        const annotationInstance = new ParamDecoratorFactory(...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.
-            const 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(() => {
+        const metaCtor = makeMetadataCtor(props);
+        function ParamDecoratorFactory(...args) {
+            if (this instanceof ParamDecoratorFactory) {
+                metaCtor.apply(this, args);
+                return this;
+            }
+            const annotationInstance = new ParamDecoratorFactory(...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.
+                const 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) {
-    const metaCtor = makeMetadataCtor(props);
-    function PropDecoratorFactory(...args) {
-        if (this instanceof PropDecoratorFactory) {
-            metaCtor.apply(this, args);
-            return this;
-        }
-        const decoratorInstance = new PropDecoratorFactory(...args);
-        function PropDecorator(target, name) {
-            const constructor = target.constructor;
-            // Use of Object.defineProperty is important since it creates non-enumerable property which
-            // prevents the property is copied during subclassing.
-            const 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(target, name, ...args);
-        }
-        return PropDecorator;
-    }
-    if (parentClass) {
-        PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
-    }
-    PropDecoratorFactory.prototype.ngMetadataName = name;
-    PropDecoratorFactory.annotationCls = PropDecoratorFactory;
-    return PropDecoratorFactory;
+    return noSideEffects(() => {
+        const metaCtor = makeMetadataCtor(props);
+        function PropDecoratorFactory(...args) {
+            if (this instanceof PropDecoratorFactory) {
+                metaCtor.apply(this, args);
+                return this;
+            }
+            const decoratorInstance = new PropDecoratorFactory(...args);
+            function PropDecorator(target, name) {
+                const constructor = target.constructor;
+                // Use of Object.defineProperty is important since it creates non-enumerable property which
+                // prevents the property is copied during subclassing.
+                const 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(target, name, ...args);
+            }
+            return PropDecorator;
+        }
+        if (parentClass) {
+            PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
+        }
+        PropDecoratorFactory.prototype.ngMetadataName = name;
+        PropDecoratorFactory.annotationCls = PropDecoratorFactory;
+        return PropDecoratorFactory;
+    });
 }
 
 /**
@@ -1306,8 +1332,6 @@ function assertDefined(actual, msg) {
     }
 }
 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]`));
 }
@@ -1759,26 +1783,6 @@ ViewEncapsulation$1[ViewEncapsulation$1.Native] = 'Native';
 ViewEncapsulation$1[ViewEncapsulation$1.None] = 'None';
 ViewEncapsulation$1[ViewEncapsulation$1.ShadowDom] = 'ShadowDom';
 
-/**
- * @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 };
-}
-
 /**
  * @fileoverview added by tsickle
  * Generated from: packages/core/src/render3/empty.ts
@@ -1831,66 +1835,66 @@ let _renderCompCount = 0;
  * @return {?}
  */
 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();
-    /** @type {?} */
-    const type = componentDefinition.type;
-    /** @type {?} */
-    const typePrototype = type.prototype;
-    /** @type {?} */
-    const declaredInputs = (/** @type {?} */ ({}));
-    /** @type {?} */
-    const def = {
-        type: type,
-        providersResolver: null,
-        decls: componentDefinition.decls,
-        vars: componentDefinition.vars,
-        factory: null,
-        template: componentDefinition.template || (/** @type {?} */ (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: (/** @type {?} */ (null)),
-        // assigned in noSideEffects
-        outputs: (/** @type {?} */ (null)),
-        // assigned in noSideEffects
-        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 === ChangeDetectionStrategy.OnPush,
-        directiveDefs: (/** @type {?} */ (null)),
-        // assigned in noSideEffects
-        pipeDefs: (/** @type {?} */ (null)),
-        // assigned in noSideEffects
-        selectors: componentDefinition.selectors || EMPTY_ARRAY,
-        viewQuery: componentDefinition.viewQuery || null,
-        features: (/** @type {?} */ (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 || ViewEncapsulation$1.Emulated,
-        id: 'c',
-        styles: componentDefinition.styles || EMPTY_ARRAY,
-        _: (/** @type {?} */ (null)),
-        setInput: null,
-        schemas: componentDefinition.schemas || null,
-        tView: null,
-    };
-    def._ = (/** @type {?} */ (noSideEffects((/**
+    return noSideEffects((/**
      * @return {?}
      */
     () => {
+        // Initialize ngDevMode. This must be the first statement in ɵɵdefineComponent.
+        // See the `initNgDevMode` docstring for more information.
+        (typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode();
+        /** @type {?} */
+        const type = componentDefinition.type;
+        /** @type {?} */
+        const typePrototype = type.prototype;
+        /** @type {?} */
+        const declaredInputs = (/** @type {?} */ ({}));
+        /** @type {?} */
+        const def = {
+            type: type,
+            providersResolver: null,
+            decls: componentDefinition.decls,
+            vars: componentDefinition.vars,
+            factory: null,
+            template: componentDefinition.template || (/** @type {?} */ (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: (/** @type {?} */ (null)),
+            // assigned in noSideEffects
+            outputs: (/** @type {?} */ (null)),
+            // assigned in noSideEffects
+            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 === ChangeDetectionStrategy.OnPush,
+            directiveDefs: (/** @type {?} */ (null)),
+            // assigned in noSideEffects
+            pipeDefs: (/** @type {?} */ (null)),
+            // assigned in noSideEffects
+            selectors: componentDefinition.selectors || EMPTY_ARRAY,
+            viewQuery: componentDefinition.viewQuery || null,
+            features: (/** @type {?} */ (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 || ViewEncapsulation$1.Emulated,
+            id: 'c',
+            styles: componentDefinition.styles || EMPTY_ARRAY,
+            _: (/** @type {?} */ (null)),
+            setInput: null,
+            schemas: componentDefinition.schemas || null,
+            tView: null,
+        };
         /** @type {?} */
         const directiveTypes = (/** @type {?} */ (componentDefinition.directives));
         /** @type {?} */
@@ -1918,8 +1922,8 @@ function ɵɵdefineComponent(componentDefinition) {
              */
             () => (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef)) :
             null;
-    }))));
-    return (/** @type {?} */ (def));
+        return (/** @type {?} */ (def));
+    }));
 }
 /**
  * \@codeGenApi
@@ -2906,6 +2910,8 @@ function isRootView(target) {
  * Generated from: packages/core/src/render3/assert.ts
  * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+// [Assert functions do not constraint type when they are guarded by a truthy
+// expression.](https://github.com/microsoft/TypeScript/issues/37295)
 /**
  * @param {?} tNode
  * @param {?} lView
@@ -3009,6 +3015,7 @@ function assertFirstUpdatePass(tView, errMessage) {
 /**
  * This is a basic sanity check that an object is probably a directive def. DirectiveDef is
  * an interface, so we can't do a direct instanceof check.
+ * @template T
  * @param {?} obj
  * @return {?}
  */
@@ -3035,6 +3042,739 @@ const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
 /** @type {?} */
 const MATH_ML_NAMESPACE = 'http://www.w3.org/1998/MathML/';
 
+/**
+ * @fileoverview added by tsickle
+ * Generated from: packages/core/src/render3/interfaces/context.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @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
+ * @type {?}
+ */
+const MONKEY_PATCH_KEY_NAME = '__ngContext__';
+/**
+ * The internal view context which is specific to a given DOM element, directive or
+ * component instance. Each value in here (besides the LView and element node details)
+ * can be present, null or undefined. If undefined then it implies the value has not been
+ * looked up yet, otherwise, if null, then a lookup was executed and nothing was found.
+ *
+ * Each value will get filled when the respective value is examined within the getContext
+ * function. The component, element and each directive instance will share the same instance
+ * of the context.
+ * @record
+ */
+function LContext() { }
+if (false) {
+    /**
+     * The component's parent view data.
+     * @type {?}
+     */
+    LContext.prototype.lView;
+    /**
+     * The index instance of the node.
+     * @type {?}
+     */
+    LContext.prototype.nodeIndex;
+    /**
+     * The instance of the DOM node that is attached to the lNode.
+     * @type {?}
+     */
+    LContext.prototype.native;
+    /**
+     * The instance of the Component node.
+     * @type {?}
+     */
+    LContext.prototype.component;
+    /**
+     * The list of active directives that exist on this element.
+     * @type {?}
+     */
+    LContext.prototype.directives;
+    /**
+     * The map of local references (local reference name => element or directive instance) that exist
+     * on this element.
+     * @type {?}
+     */
+    LContext.prototype.localRefs;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: packages/core/src/render3/interfaces/document.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @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.
+ * @type {?}
+ */
+let 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.
+ * @return {?}
+ */
+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.
+ * @return {?}
+ */
+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 (/** @type {?} */ (undefined));
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: packages/core/src/render3/interfaces/renderer.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {number} */
+const RendererStyleFlags3 = {
+    Important: 1,
+    DashCase: 2,
+};
+RendererStyleFlags3[RendererStyleFlags3.Important] = 'Important';
+RendererStyleFlags3[RendererStyleFlags3.DashCase] = 'DashCase';
+/**
+ * Object Oriented style of API needed to create elements and text nodes.
+ *
+ * This is the native browser API style, e.g. operations are methods on individual objects
+ * like HTMLElement. With this style, no additional code is needed as a facade
+ * (reducing payload size).
+ *
+ * @record
+ */
+function ObjectOrientedRenderer3() { }
+if (false) {
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createComment = function (data) { };
+    /**
+     * @param {?} tagName
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createElement = function (tagName) { };
+    /**
+     * @param {?} namespace
+     * @param {?} tagName
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createElementNS = function (namespace, tagName) { };
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.createTextNode = function (data) { };
+    /**
+     * @param {?} selectors
+     * @return {?}
+     */
+    ObjectOrientedRenderer3.prototype.querySelector = function (selectors) { };
+}
+/**
+ * Returns whether the `renderer` is a `ProceduralRenderer3`
+ * @param {?} renderer
+ * @return {?}
+ */
+function isProceduralRenderer(renderer) {
+    return !!(((/** @type {?} */ (renderer))).listen);
+}
+/**
+ * Procedural style of API needed to create elements and text nodes.
+ *
+ * In non-native browser environments (e.g. platforms such as web-workers), this is the
+ * facade that enables element manipulation. This also facilitates backwards compatibility
+ * with Renderer2.
+ * @record
+ */
+function ProceduralRenderer3() { }
+if (false) {
+    /**
+     * This property is allowed to be null / undefined,
+     * in which case the view engine won't call it.
+     * This is used as a performance optimization for production mode.
+     * @type {?|undefined}
+     */
+    ProceduralRenderer3.prototype.destroyNode;
+    /**
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.destroy = function () { };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.createComment = function (value) { };
+    /**
+     * @param {?} name
+     * @param {?=} namespace
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.createElement = function (name, namespace) { };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.createText = function (value) { };
+    /**
+     * @param {?} parent
+     * @param {?} newChild
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.appendChild = function (parent, newChild) { };
+    /**
+     * @param {?} parent
+     * @param {?} newChild
+     * @param {?} refChild
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.insertBefore = function (parent, newChild, refChild) { };
+    /**
+     * @param {?} parent
+     * @param {?} oldChild
+     * @param {?=} isHostElement
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeChild = function (parent, oldChild, isHostElement) { };
+    /**
+     * @param {?} selectorOrNode
+     * @param {?=} preserveContent
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.selectRootElement = function (selectorOrNode, preserveContent) { };
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.parentNode = function (node) { };
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.nextSibling = function (node) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @param {?} value
+     * @param {?=} namespace
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setAttribute = function (el, name, value, namespace) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @param {?=} namespace
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeAttribute = function (el, name, namespace) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.addClass = function (el, name) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeClass = function (el, name) { };
+    /**
+     * @param {?} el
+     * @param {?} style
+     * @param {?} value
+     * @param {?=} flags
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setStyle = function (el, style, value, flags) { };
+    /**
+     * @param {?} el
+     * @param {?} style
+     * @param {?=} flags
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.removeStyle = function (el, style, flags) { };
+    /**
+     * @param {?} el
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setProperty = function (el, name, value) { };
+    /**
+     * @param {?} node
+     * @param {?} value
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.setValue = function (node, value) { };
+    /**
+     * @param {?} target
+     * @param {?} eventName
+     * @param {?} callback
+     * @return {?}
+     */
+    ProceduralRenderer3.prototype.listen = function (target, eventName, callback) { };
+}
+/**
+ * @record
+ */
+function RendererFactory3() { }
+if (false) {
+    /**
+     * @param {?} hostElement
+     * @param {?} rendererType
+     * @return {?}
+     */
+    RendererFactory3.prototype.createRenderer = function (hostElement, rendererType) { };
+    /**
+     * @return {?}
+     */
+    RendererFactory3.prototype.begin = function () { };
+    /**
+     * @return {?}
+     */
+    RendererFactory3.prototype.end = function () { };
+}
+const ɵ0$2 = /**
+ * @param {?} hostElement
+ * @param {?} rendererType
+ * @return {?}
+ */
+(hostElement, rendererType) => { return getDocument(); };
+/** @type {?} */
+const domRendererFactory3 = {
+    createRenderer: (ɵ0$2)
+};
+/**
+ * Subset of API needed for appending elements and text nodes.
+ * @record
+ */
+function RNode() { }
+if (false) {
+    /**
+     * Returns the parent Element, Document, or DocumentFragment
+     * @type {?}
+     */
+    RNode.prototype.parentNode;
+    /**
+     * Returns the parent Element if there is one
+     * @type {?}
+     */
+    RNode.prototype.parentElement;
+    /**
+     * Gets the Node immediately following this one in the parent's childNodes
+     * @type {?}
+     */
+    RNode.prototype.nextSibling;
+    /**
+     * Removes a child from the current node and returns the removed node
+     * @param {?} oldChild the child node to remove
+     * @return {?}
+     */
+    RNode.prototype.removeChild = function (oldChild) { };
+    /**
+     * Insert a child node.
+     *
+     * Used exclusively for adding View root nodes into ViewAnchor location.
+     * @param {?} newChild
+     * @param {?} refChild
+     * @param {?} isViewRoot
+     * @return {?}
+     */
+    RNode.prototype.insertBefore = function (newChild, refChild, isViewRoot) { };
+    /**
+     * Append a child node.
+     *
+     * Used exclusively for building up DOM which are static (ie not View roots)
+     * @param {?} newChild
+     * @return {?}
+     */
+    RNode.prototype.appendChild = function (newChild) { };
+}
+/**
+ * Subset of API needed for writing attributes, properties, and setting up
+ * listeners on Element.
+ * @record
+ */
+function RElement() { }
+if (false) {
+    /** @type {?} */
+    RElement.prototype.style;
+    /** @type {?} */
+    RElement.prototype.classList;
+    /** @type {?} */
+    RElement.prototype.className;
+    /** @type {?} */
+    RElement.prototype.textContent;
+    /**
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    RElement.prototype.setAttribute = function (name, value) { };
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    RElement.prototype.removeAttribute = function (name) { };
+    /**
+     * @param {?} namespaceURI
+     * @param {?} qualifiedName
+     * @param {?} value
+     * @return {?}
+     */
+    RElement.prototype.setAttributeNS = function (namespaceURI, qualifiedName, value) { };
+    /**
+     * @param {?} type
+     * @param {?} listener
+     * @param {?=} useCapture
+     * @return {?}
+     */
+    RElement.prototype.addEventListener = function (type, listener, useCapture) { };
+    /**
+     * @param {?} type
+     * @param {?=} listener
+     * @param {?=} options
+     * @return {?}
+     */
+    RElement.prototype.removeEventListener = function (type, listener, options) { };
+    /**
+     * @param {?} name
+     * @param {?} value
+     * @return {?}
+     */
+    RElement.prototype.setProperty = function (name, value) { };
+}
+/**
+ * @record
+ */
+function RCssStyleDeclaration() { }
+if (false) {
+    /**
+     * @param {?} propertyName
+     * @return {?}
+     */
+    RCssStyleDeclaration.prototype.removeProperty = function (propertyName) { };
+    /**
+     * @param {?} propertyName
+     * @param {?} value
+     * @param {?=} priority
+     * @return {?}
+     */
+    RCssStyleDeclaration.prototype.setProperty = function (propertyName, value, priority) { };
+}
+/**
+ * @record
+ */
+function RDomTokenList() { }
+if (false) {
+    /**
+     * @param {?} token
+     * @return {?}
+     */
+    RDomTokenList.prototype.add = function (token) { };
+    /**
+     * @param {?} token
+     * @return {?}
+     */
+    RDomTokenList.prototype.remove = function (token) { };
+}
+/**
+ * @record
+ */
+function RText() { }
+if (false) {
+    /** @type {?} */
+    RText.prototype.textContent;
+}
+/**
+ * @record
+ */
+function RComment() { }
+if (false) {
+    /** @type {?} */
+    RComment.prototype.textContent;
+}
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
+/** @type {?} */
+const unusedValueExportToPlacateAjd$2 = 1;
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: packages/core/src/render3/util/view_utils.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * 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`
+ * @return {?}
+ */
+function unwrapRNode(value) {
+    while (Array.isArray(value)) {
+        value = (/** @type {?} */ (value[HOST]));
+    }
+    return (/** @type {?} */ (value));
+}
+/**
+ * Returns `LView` or `null` if not found.
+ * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`
+ * @return {?}
+ */
+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 (/** @type {?} */ (value));
+        value = (/** @type {?} */ (value[HOST]));
+    }
+    return null;
+}
+/**
+ * Returns `LContainer` or `null` if not found.
+ * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`
+ * @return {?}
+ */
+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 (/** @type {?} */ (value));
+        value = (/** @type {?} */ (value[HOST]));
+    }
+    return null;
+}
+/**
+ * Retrieves an element value from the provided `viewData`, by unwrapping
+ * from any containers, component views, or style contexts.
+ * @param {?} index
+ * @param {?} lView
+ * @return {?}
+ */
+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
+ * @return {?}
+ */
+function getNativeByTNode(tNode, lView) {
+    ngDevMode && assertTNodeForLView(tNode, lView);
+    ngDevMode && assertDataInRange(lView, tNode.index);
+    /** @type {?} */
+    const 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
+ * @return {?}
+ */
+function getNativeByTNodeOrNull(tNode, lView) {
+    /** @type {?} */
+    const index = tNode.index;
+    if (index !== -1) {
+        ngDevMode && assertTNodeForLView(tNode, lView);
+        /** @type {?} */
+        const node = unwrapRNode(lView[index]);
+        ngDevMode && node !== null && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
+        return node;
+    }
+    return null;
+}
+/**
+ * @param {?} tView
+ * @param {?} index
+ * @return {?}
+ */
+function getTNode(tView, index) {
+    ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
+    ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
+    return (/** @type {?} */ (tView.data[index + HEADER_OFFSET]));
+}
+/**
+ * Retrieves a value from any `LView` or `TData`.
+ * @template T
+ * @param {?} view
+ * @param {?} index
+ * @return {?}
+ */
+function load(view, index) {
+    ngDevMode && assertDataInRange(view, index + HEADER_OFFSET);
+    return view[index + HEADER_OFFSET];
+}
+/**
+ * @param {?} nodeIndex
+ * @param {?} hostView
+ * @return {?}
+ */
+function getComponentLViewByIndex(nodeIndex, hostView) {
+    // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
+    ngDevMode && assertDataInRange(hostView, nodeIndex);
+    /** @type {?} */
+    const slotValue = hostView[nodeIndex];
+    /** @type {?} */
+    const 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).
+ * @param {?} target
+ * @return {?}
+ */
+function readPatchedData(target) {
+    ngDevMode && assertDefined(target, 'Target expected');
+    return target[MONKEY_PATCH_KEY_NAME] || null;
+}
+/**
+ * @param {?} target
+ * @return {?}
+ */
+function readPatchedLView(target) {
+    /** @type {?} */
+    const value = readPatchedData(target);
+    if (value) {
+        return Array.isArray(value) ? value : ((/** @type {?} */ (value))).lView;
+    }
+    return null;
+}
+/**
+ * Checks whether a given view is in creation mode
+ * @param {?} view
+ * @return {?}
+ */
+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.
+ * @param {?} view
+ * @return {?}
+ */
+function viewAttachedToChangeDetector(view) {
+    return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;
+}
+/**
+ * Returns a boolean for whether the view is attached to a container.
+ * @param {?} view
+ * @return {?}
+ */
+function viewAttachedToContainer(view) {
+    return isLContainer(view[PARENT]);
+}
+/**
+ * Returns a constant from `TConstants` instance.
+ * @template T
+ * @param {?} consts
+ * @param {?} index
+ * @return {?}
+ */
+function getConstant(consts, index) {
+    return consts === null || index == null ? null : (/** @type {?} */ ((/** @type {?} */ (consts[index]))));
+}
+/**
+ * Resets the pre-order hook flags of the view.
+ * @param {?} lView the LView on which the flags are reset
+ * @return {?}
+ */
+function resetPreOrderHookFlags(lView) {
+    lView[PREORDER_HOOK_FLAGS] = 0;
+}
+/**
+ * @param {?} lContainer
+ * @return {?}
+ */
+function getLContainerActiveIndex(lContainer) {
+    return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
+}
+/**
+ * @param {?} lContainer
+ * @param {?} index
+ * @return {?}
+ */
+function setLContainerActiveIndex(lContainer, index) {
+    lContainer[ACTIVE_INDEX] = index << 1 /* SHIFT */;
+}
+
 /**
  * @fileoverview added by tsickle
  * Generated from: packages/core/src/render3/state.ts
@@ -3641,6 +4381,15 @@ function getSelectedIndex() {
 function setSelectedIndex(index) {
     instructionState.lFrame.selectedIndex = index;
 }
+/**
+ * Gets the `tNode` that represents currently selected element.
+ * @return {?}
+ */
+function getSelectedTNode() {
+    /** @type {?} */
+    const 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.
  *
@@ -4193,7 +4942,7 @@ function isFactory(obj) {
 // Note: This hack is necessary so we don't erroneously get a circular dependency
 // failure based on types.
 /** @type {?} */
-const unusedValueExportToPlacateAjd$2 = 1;
+const unusedValueExportToPlacateAjd$3 = 1;
 
 /**
  * @fileoverview added by tsickle
@@ -4244,448 +4993,6 @@ function typeName(type) {
     return '<unknown>';
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: packages/core/src/render3/interfaces/document.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @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.
- * @type {?}
- */
-let 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.
- * @return {?}
- */
-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.
- * @return {?}
- */
-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 (/** @type {?} */ (undefined));
-}
-
-/**
- * @fileoverview added by tsickle
- * Generated from: packages/core/src/render3/interfaces/renderer.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @enum {number} */
-const RendererStyleFlags3 = {
-    Important: 1,
-    DashCase: 2,
-};
-RendererStyleFlags3[RendererStyleFlags3.Important] = 'Important';
-RendererStyleFlags3[RendererStyleFlags3.DashCase] = 'DashCase';
-/**
- * Object Oriented style of API needed to create elements and text nodes.
- *
- * This is the native browser API style, e.g. operations are methods on individual objects
- * like HTMLElement. With this style, no additional code is needed as a facade
- * (reducing payload size).
- *
- * @record
- */
-function ObjectOrientedRenderer3() { }
-if (false) {
-    /**
-     * @param {?} data
-     * @return {?}
-     */
-    ObjectOrientedRenderer3.prototype.createComment = function (data) { };
-    /**
-     * @param {?} tagName
-     * @return {?}
-     */
-    ObjectOrientedRenderer3.prototype.createElement = function (tagName) { };
-    /**
-     * @param {?} namespace
-     * @param {?} tagName
-     * @return {?}
-     */
-    ObjectOrientedRenderer3.prototype.createElementNS = function (namespace, tagName) { };
-    /**
-     * @param {?} data
-     * @return {?}
-     */
-    ObjectOrientedRenderer3.prototype.createTextNode = function (data) { };
-    /**
-     * @param {?} selectors
-     * @return {?}
-     */
-    ObjectOrientedRenderer3.prototype.querySelector = function (selectors) { };
-}
-/**
- * Returns whether the `renderer` is a `ProceduralRenderer3`
- * @param {?} renderer
- * @return {?}
- */
-function isProceduralRenderer(renderer) {
-    return !!(((/** @type {?} */ (renderer))).listen);
-}
-/**
- * Procedural style of API needed to create elements and text nodes.
- *
- * In non-native browser environments (e.g. platforms such as web-workers), this is the
- * facade that enables element manipulation. This also facilitates backwards compatibility
- * with Renderer2.
- * @record
- */
-function ProceduralRenderer3() { }
-if (false) {
-    /**
-     * This property is allowed to be null / undefined,
-     * in which case the view engine won't call it.
-     * This is used as a performance optimization for production mode.
-     * @type {?|undefined}
-     */
-    ProceduralRenderer3.prototype.destroyNode;
-    /**
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.destroy = function () { };
-    /**
-     * @param {?} value
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.createComment = function (value) { };
-    /**
-     * @param {?} name
-     * @param {?=} namespace
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.createElement = function (name, namespace) { };
-    /**
-     * @param {?} value
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.createText = function (value) { };
-    /**
-     * @param {?} parent
-     * @param {?} newChild
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.appendChild = function (parent, newChild) { };
-    /**
-     * @param {?} parent
-     * @param {?} newChild
-     * @param {?} refChild
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.insertBefore = function (parent, newChild, refChild) { };
-    /**
-     * @param {?} parent
-     * @param {?} oldChild
-     * @param {?=} isHostElement
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.removeChild = function (parent, oldChild, isHostElement) { };
-    /**
-     * @param {?} selectorOrNode
-     * @param {?=} preserveContent
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.selectRootElement = function (selectorOrNode, preserveContent) { };
-    /**
-     * @param {?} node
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.parentNode = function (node) { };
-    /**
-     * @param {?} node
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.nextSibling = function (node) { };
-    /**
-     * @param {?} el
-     * @param {?} name
-     * @param {?} value
-     * @param {?=} namespace
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.setAttribute = function (el, name, value, namespace) { };
-    /**
-     * @param {?} el
-     * @param {?} name
-     * @param {?=} namespace
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.removeAttribute = function (el, name, namespace) { };
-    /**
-     * @param {?} el
-     * @param {?} name
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.addClass = function (el, name) { };
-    /**
-     * @param {?} el
-     * @param {?} name
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.removeClass = function (el, name) { };
-    /**
-     * @param {?} el
-     * @param {?} style
-     * @param {?} value
-     * @param {?=} flags
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.setStyle = function (el, style, value, flags) { };
-    /**
-     * @param {?} el
-     * @param {?} style
-     * @param {?=} flags
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.removeStyle = function (el, style, flags) { };
-    /**
-     * @param {?} el
-     * @param {?} name
-     * @param {?} value
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.setProperty = function (el, name, value) { };
-    /**
-     * @param {?} node
-     * @param {?} value
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.setValue = function (node, value) { };
-    /**
-     * @param {?} target
-     * @param {?} eventName
-     * @param {?} callback
-     * @return {?}
-     */
-    ProceduralRenderer3.prototype.listen = function (target, eventName, callback) { };
-}
-/**
- * @record
- */
-function RendererFactory3() { }
-if (false) {
-    /**
-     * @param {?} hostElement
-     * @param {?} rendererType
-     * @return {?}
-     */
-    RendererFactory3.prototype.createRenderer = function (hostElement, rendererType) { };
-    /**
-     * @return {?}
-     */
-    RendererFactory3.prototype.begin = function () { };
-    /**
-     * @return {?}
-     */
-    RendererFactory3.prototype.end = function () { };
-}
-const ɵ0$2 = /**
- * @param {?} hostElement
- * @param {?} rendererType
- * @return {?}
- */
-(hostElement, rendererType) => { return getDocument(); };
-/** @type {?} */
-const domRendererFactory3 = {
-    createRenderer: (ɵ0$2)
-};
-/**
- * Subset of API needed for appending elements and text nodes.
- * @record
- */
-function RNode() { }
-if (false) {
-    /**
-     * Returns the parent Element, Document, or DocumentFragment
-     * @type {?}
-     */
-    RNode.prototype.parentNode;
-    /**
-     * Returns the parent Element if there is one
-     * @type {?}
-     */
-    RNode.prototype.parentElement;
-    /**
-     * Gets the Node immediately following this one in the parent's childNodes
-     * @type {?}
-     */
-    RNode.prototype.nextSibling;
-    /**
-     * Removes a child from the current node and returns the removed node
-     * @param {?} oldChild the child node to remove
-     * @return {?}
-     */
-    RNode.prototype.removeChild = function (oldChild) { };
-    /**
-     * Insert a child node.
-     *
-     * Used exclusively for adding View root nodes into ViewAnchor location.
-     * @param {?} newChild
-     * @param {?} refChild
-     * @param {?} isViewRoot
-     * @return {?}
-     */
-    RNode.prototype.insertBefore = function (newChild, refChild, isViewRoot) { };
-    /**
-     * Append a child node.
-     *
-     * Used exclusively for building up DOM which are static (ie not View roots)
-     * @param {?} newChild
-     * @return {?}
-     */
-    RNode.prototype.appendChild = function (newChild) { };
-}
-/**
- * Subset of API needed for writing attributes, properties, and setting up
- * listeners on Element.
- * @record
- */
-function RElement() { }
-if (false) {
-    /** @type {?} */
-    RElement.prototype.style;
-    /** @type {?} */
-    RElement.prototype.classList;
-    /** @type {?} */
-    RElement.prototype.className;
-    /** @type {?} */
-    RElement.prototype.textContent;
-    /**
-     * @param {?} name
-     * @param {?} value
-     * @return {?}
-     */
-    RElement.prototype.setAttribute = function (name, value) { };
-    /**
-     * @param {?} name
-     * @return {?}
-     */
-    RElement.prototype.removeAttribute = function (name) { };
-    /**
-     * @param {?} namespaceURI
-     * @param {?} qualifiedName
-     * @param {?} value
-     * @return {?}
-     */
-    RElement.prototype.setAttributeNS = function (namespaceURI, qualifiedName, value) { };
-    /**
-     * @param {?} type
-     * @param {?} listener
-     * @param {?=} useCapture
-     * @return {?}
-     */
-    RElement.prototype.addEventListener = function (type, listener, useCapture) { };
-    /**
-     * @param {?} type
-     * @param {?=} listener
-     * @param {?=} options
-     * @return {?}
-     */
-    RElement.prototype.removeEventListener = function (type, listener, options) { };
-    /**
-     * @param {?} name
-     * @param {?} value
-     * @return {?}
-     */
-    RElement.prototype.setProperty = function (name, value) { };
-}
-/**
- * @record
- */
-function RCssStyleDeclaration() { }
-if (false) {
-    /**
-     * @param {?} propertyName
-     * @return {?}
-     */
-    RCssStyleDeclaration.prototype.removeProperty = function (propertyName) { };
-    /**
-     * @param {?} propertyName
-     * @param {?} value
-     * @param {?=} priority
-     * @return {?}
-     */
-    RCssStyleDeclaration.prototype.setProperty = function (propertyName, value, priority) { };
-}
-/**
- * @record
- */
-function RDomTokenList() { }
-if (false) {
-    /**
-     * @param {?} token
-     * @return {?}
-     */
-    RDomTokenList.prototype.add = function (token) { };
-    /**
-     * @param {?} token
-     * @return {?}
-     */
-    RDomTokenList.prototype.remove = function (token) { };
-}
-/**
- * @record
- */
-function RText() { }
-if (false) {
-    /** @type {?} */
-    RText.prototype.textContent;
-}
-/**
- * @record
- */
-function RComment() { }
-if (false) {
-    /** @type {?} */
-    RComment.prototype.textContent;
-}
-// Note: This hack is necessary so we don't erroneously get a circular dependency
-// failure based on types.
-/** @type {?} */
-const unusedValueExportToPlacateAjd$3 = 1;
-
 /**
  * @fileoverview added by tsickle
  * Generated from: packages/core/src/render3/util/attrs_utils.ts
@@ -5793,24 +6100,29 @@ function ɵɵgetFactoryOf(type) {
  * @return {?}
  */
 function ɵɵgetInheritedFactory(type) {
-    /** @type {?} */
-    const proto = (/** @type {?} */ (Object.getPrototypeOf(type.prototype).constructor));
-    /** @type {?} */
-    const factory = ((/** @type {?} */ (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 (/**
-         * @param {?} t
-         * @return {?}
-         */
-        (t) => new t());
-    }
+    return noSideEffects((/**
+     * @return {?}
+     */
+    () => {
+        /** @type {?} */
+        const proto = (/** @type {?} */ (Object.getPrototypeOf(type.prototype).constructor));
+        /** @type {?} */
+        const factory = ((/** @type {?} */ (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 (/**
+             * @param {?} t
+             * @return {?}
+             */
+            (t) => new t());
+        }
+    }));
 }
 
 /**
@@ -7350,297 +7662,6 @@ function normalizeDebugBindingValue(value) {
     }
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: packages/core/src/render3/interfaces/context.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @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
- * @type {?}
- */
-const MONKEY_PATCH_KEY_NAME = '__ngContext__';
-/**
- * The internal view context which is specific to a given DOM element, directive or
- * component instance. Each value in here (besides the LView and element node details)
- * can be present, null or undefined. If undefined then it implies the value has not been
- * looked up yet, otherwise, if null, then a lookup was executed and nothing was found.
- *
- * Each value will get filled when the respective value is examined within the getContext
- * function. The component, element and each directive instance will share the same instance
- * of the context.
- * @record
- */
-function LContext() { }
-if (false) {
-    /**
-     * The component's parent view data.
-     * @type {?}
-     */
-    LContext.prototype.lView;
-    /**
-     * The index instance of the node.
-     * @type {?}
-     */
-    LContext.prototype.nodeIndex;
-    /**
-     * The instance of the DOM node that is attached to the lNode.
-     * @type {?}
-     */
-    LContext.prototype.native;
-    /**
-     * The instance of the Component node.
-     * @type {?}
-     */
-    LContext.prototype.component;
-    /**
-     * The list of active directives that exist on this element.
-     * @type {?}
-     */
-    LContext.prototype.directives;
-    /**
-     * The map of local references (local reference name => element or directive instance) that exist
-     * on this element.
-     * @type {?}
-     */
-    LContext.prototype.localRefs;
-}
-
-/**
- * @fileoverview added by tsickle
- * Generated from: packages/core/src/render3/util/view_utils.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * 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`
- * @return {?}
- */
-function unwrapRNode(value) {
-    while (Array.isArray(value)) {
-        value = (/** @type {?} */ (value[HOST]));
-    }
-    return (/** @type {?} */ (value));
-}
-/**
- * Returns `LView` or `null` if not found.
- * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`
- * @return {?}
- */
-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 (/** @type {?} */ (value));
-        value = (/** @type {?} */ (value[HOST]));
-    }
-    return null;
-}
-/**
- * Returns `LContainer` or `null` if not found.
- * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`
- * @return {?}
- */
-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 (/** @type {?} */ (value));
-        value = (/** @type {?} */ (value[HOST]));
-    }
-    return null;
-}
-/**
- * Retrieves an element value from the provided `viewData`, by unwrapping
- * from any containers, component views, or style contexts.
- * @param {?} index
- * @param {?} lView
- * @return {?}
- */
-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
- * @return {?}
- */
-function getNativeByTNode(tNode, lView) {
-    ngDevMode && assertTNodeForLView(tNode, lView);
-    ngDevMode && assertDataInRange(lView, tNode.index);
-    /** @type {?} */
-    const 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
- * @return {?}
- */
-function getNativeByTNodeOrNull(tNode, lView) {
-    /** @type {?} */
-    const index = tNode.index;
-    if (index !== -1) {
-        ngDevMode && assertTNodeForLView(tNode, lView);
-        /** @type {?} */
-        const node = unwrapRNode(lView[index]);
-        ngDevMode && node !== null && !isProceduralRenderer(lView[RENDERER]) && assertDomNode(node);
-        return node;
-    }
-    return null;
-}
-/**
- * @param {?} tView
- * @param {?} index
- * @return {?}
- */
-function getTNode(tView, index) {
-    ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
-    ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
-    return (/** @type {?} */ (tView.data[index + HEADER_OFFSET]));
-}
-/**
- * Retrieves a value from any `LView` or `TData`.
- * @template T
- * @param {?} view
- * @param {?} index
- * @return {?}
- */
-function load(view, index) {
-    ngDevMode && assertDataInRange(view, index + HEADER_OFFSET);
-    return view[index + HEADER_OFFSET];
-}
-/**
- * @param {?} nodeIndex
- * @param {?} hostView
- * @return {?}
- */
-function getComponentLViewByIndex(nodeIndex, hostView) {
-    // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
-    ngDevMode && assertDataInRange(hostView, nodeIndex);
-    /** @type {?} */
-    const slotValue = hostView[nodeIndex];
-    /** @type {?} */
-    const 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).
- * @param {?} target
- * @return {?}
- */
-function readPatchedData(target) {
-    ngDevMode && assertDefined(target, 'Target expected');
-    return target[MONKEY_PATCH_KEY_NAME] || null;
-}
-/**
- * @param {?} target
- * @return {?}
- */
-function readPatchedLView(target) {
-    /** @type {?} */
-    const value = readPatchedData(target);
-    if (value) {
-        return Array.isArray(value) ? value : ((/** @type {?} */ (value))).lView;
-    }
-    return null;
-}
-/**
- * Checks whether a given view is in creation mode
- * @param {?} view
- * @return {?}
- */
-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.
- * @param {?} view
- * @return {?}
- */
-function viewAttachedToChangeDetector(view) {
-    return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;
-}
-/**
- * Returns a boolean for whether the view is attached to a container.
- * @param {?} view
- * @return {?}
- */
-function viewAttachedToContainer(view) {
-    return isLContainer(view[PARENT]);
-}
-/**
- * Returns a constant from `TConstants` instance.
- * @template T
- * @param {?} consts
- * @param {?} index
- * @return {?}
- */
-function getConstant(consts, index) {
-    return consts === null || index == null ? null : (/** @type {?} */ ((/** @type {?} */ (consts[index]))));
-}
-/**
- * Resets the pre-order hook flags of the view.
- * @param {?} lView the LView on which the flags are reset
- * @return {?}
- */
-function resetPreOrderHookFlags(lView) {
-    lView[PREORDER_HOOK_FLAGS] = 0;
-}
-/**
- * @param {?} lContainer
- * @return {?}
- */
-function getLContainerActiveIndex(lContainer) {
-    return lContainer[ACTIVE_INDEX] >> 1 /* SHIFT */;
-}
-/**
- * @param {?} lContainer
- * @param {?} index
- * @return {?}
- */
-function setLContainerActiveIndex(lContainer, index) {
-    lContainer[ACTIVE_INDEX] = index << 1 /* SHIFT */;
-}
-
 /**
  * @fileoverview added by tsickle
  * Generated from: packages/core/src/render3/context_discovery.ts
@@ -8068,8 +8089,6 @@ function throwErrorIfNoChangesMode(creationMode, oldValue, currValue, propName)
     }
     // 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);
 }
 /**
@@ -12327,7 +12346,7 @@ function initializeInputAndOutputAliases(tView, tNode) {
         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')) {
@@ -12368,21 +12387,19 @@ function mapPropName(name) {
 /**
  * @template T
  * @param {?} tView
+ * @param {?} tNode
  * @param {?} lView
- * @param {?} index
  * @param {?} propName
  * @param {?} value
- * @param {?=} sanitizer
- * @param {?=} nativeOnly
- * @param {?=} loadRendererFn
+ * @param {?} renderer
+ * @param {?} sanitizer
+ * @param {?} nativeOnly
  * @return {?}
  */
-function elementPropertyInternal(tView, lView, index, propName, value, sanitizer, nativeOnly, loadRendererFn) {
+function elementPropertyInternal(tView, tNode, lView, propName, value, renderer, sanitizer, nativeOnly) {
     ngDevMode && assertNotSame(value, (/** @type {?} */ (NO_CHANGE)), 'Incoming value should never be NO_CHANGE.');
     /** @type {?} */
-    const element = (/** @type {?} */ (getNativeByIndex(index, lView)));
-    /** @type {?} */
-    const tNode = getTNode(tView, index);
+    const element = (/** @type {?} */ (getNativeByTNode(tNode, lView)));
     /** @type {?} */
     let inputData = tNode.inputs;
     /** @type {?} */
@@ -12390,7 +12407,7 @@ function elementPropertyInternal(tView, lView, index, propName, value, sanitizer
     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);
         }
@@ -12406,8 +12423,6 @@ function elementPropertyInternal(tView, lView, index, propName, value, sanitizer
             }
             ngDevMode.rendererSetProperty++;
         }
-        /** @type {?} */
-        const 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 ? ((/** @type {?} */ (sanitizer(value, tNode.tagName || '', propName)))) : value;
@@ -12962,20 +12977,19 @@ function addComponentLogic(lView, hostTNode, def) {
     lView[hostTNode.index] = componentView;
 }
 /**
- * @param {?} index
+ * @param {?} tNode
+ * @param {?} lView
  * @param {?} name
  * @param {?} value
- * @param {?} tView
- * @param {?} lView
- * @param {?=} sanitizer
- * @param {?=} namespace
+ * @param {?} sanitizer
+ * @param {?} namespace
  * @return {?}
  */
-function elementAttributeInternal(index, name, value, tView, lView, sanitizer, namespace) {
+function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
     ngDevMode && assertNotSame(value, (/** @type {?} */ (NO_CHANGE)), 'Incoming value should never be NO_CHANGE.');
     ngDevMode && validateAgainstEventAttributes(name);
     /** @type {?} */
-    const element = (/** @type {?} */ (getNativeByIndex(index, lView)));
+    const element = (/** @type {?} */ (getNativeByTNode(tNode, lView)));
     /** @type {?} */
     const renderer = lView[RENDERER];
     if (value == null) {
@@ -12986,8 +13000,6 @@ function elementAttributeInternal(index, name, value, tView, lView, sanitizer, n
     else {
         ngDevMode && ngDevMode.rendererSetAttribute++;
         /** @type {?} */
-        const tNode = getTNode(tView, index);
-        /** @type {?} */
         const strValue = sanitizer == null ? renderStringify(value) : sanitizer(value, tNode.tagName || '', name);
         if (isProceduralRenderer(renderer)) {
             renderer.setAttribute(element, name, strValue, namespace);
@@ -13478,19 +13490,17 @@ function executeViewQueryFn(flags, viewQueryFn, component) {
  * 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)
  * @return {?}
  */
-function storePropertyBindingMetadata(tData, nodeIndex, propertyName, bindingIndex, ...interpolationParts) {
+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) {
-        /** @type {?} */
-        const tNode = (/** @type {?} */ (tData[nodeIndex + HEADER_OFFSET]));
         if (tNode.inputs == null || !tNode.inputs[propertyName]) {
             /** @type {?} */
             const propBindingIdxs = tNode.propertyBindings || (tNode.propertyBindings = []);
@@ -13602,7 +13612,7 @@ function textBindingInternal(lView, index, value) {
  * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /** @type {?} */
-const unusedValueToPlacateAjd$1 = unusedValueExportToPlacateAjd$1 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$3 + unusedValueExportToPlacateAjd;
+const unusedValueToPlacateAjd$1 = unusedValueExportToPlacateAjd$1 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$5 + unusedValueExportToPlacateAjd$2 + unusedValueExportToPlacateAjd;
 /**
  * @param {?} tNode
  * @param {?} embeddedView
@@ -16187,7 +16197,7 @@ function compileInjectable(type, srcMeta) {
                         typeArgumentCount: metadata.typeArgumentCount,
                         deps: reflectDependencies(type),
                         injectFn: 'inject',
-                        target: compiler.R3FactoryTarget.Pipe
+                        target: compiler.R3FactoryTarget.Injectable
                     });
                 }
                 return ngFactoryDef;
@@ -16471,8 +16481,23 @@ if (false) {
  * @return {?}
  */
 function createInjector(defType, parent = null, additionalProviders = null, name) {
-    parent = parent || getNullInjector();
-    return new R3Injector(defType, additionalProviders, parent, name);
+    /** @type {?} */
+    const 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`.
+ * @param {?} defType
+ * @param {?=} parent
+ * @param {?=} additionalProviders
+ * @param {?=} name
+ * @return {?}
+ */
+function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name) {
+    return new R3Injector(defType, additionalProviders, parent || getNullInjector(), name);
 }
 class R3Injector {
     /**
@@ -16520,12 +16545,6 @@ class R3Injector {
         /** @type {?} */
         const record = this.records.get(INJECTOR_SCOPE);
         this.scope = record != null ? record.value : null;
-        // Eagerly instantiate the InjectorType classes themselves.
-        this.injectorDefTypes.forEach((/**
-         * @param {?} defType
-         * @return {?}
-         */
-        defType => this.get(defType)));
         // Source name, used for debugging
         this.source = source || (typeof def === 'object' ? null : stringify(def));
     }
@@ -16632,6 +16651,15 @@ class R3Injector {
             setCurrentInjector(previousInjector);
         }
     }
+    /**
+     * \@internal
+     * @return {?}
+     */
+    _resolveInjectorDefTypes() { this.injectorDefTypes.forEach((/**
+     * @param {?} defType
+     * @return {?}
+     */
+    defType => this.get(defType))); }
     /**
      * @return {?}
      */
@@ -19822,12 +19850,12 @@ function ɵɵattribute(name, value, sanitizer, namespace) {
     /** @type {?} */
     const bindingIndex = nextBindingIndex();
     if (bindingUpdated(lView, bindingIndex, value)) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementAttributeInternal(nodeIndex, name, value, tView, lView, sanitizer, namespace);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + name, bindingIndex);
+        /** @type {?} */
+        const tNode = getSelectedTNode();
+        elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace);
+        ngDevMode && storePropertyBindingMetadata(tView.data, tNode, 'attr.' + name, bindingIndex);
     }
     return ɵɵattribute;
 }
@@ -20118,12 +20146,10 @@ function ɵɵattributeInterpolate1(attrName, prefix, v0, suffix, sanitizer, name
     const interpolatedValue = interpolation1(lView, prefix, v0, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const tView = getTView();
-        elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
+        const 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;
 }
@@ -20161,12 +20187,10 @@ function ɵɵattributeInterpolate2(attrName, prefix, v0, i0, v1, suffix, sanitiz
     const interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const tView = getTView();
-        elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
+        const 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;
 }
@@ -20207,11 +20231,9 @@ function ɵɵattributeInterpolate3(attrName, prefix, v0, i0, v1, i1, v2, suffix,
     const interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const tView = getTView();
-        elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 3, prefix, i0, i1, suffix);
+        const tNode = getSelectedTNode();
+        elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
+        ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - 3, prefix, i0, i1, suffix);
     }
     return ɵɵattributeInterpolate3;
 }
@@ -20254,11 +20276,9 @@ function ɵɵattributeInterpolate4(attrName, prefix, v0, i0, v1, i1, v2, i2, v3,
     const interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const tView = getTView();
-        elementAttributeInternal(nodeIndex, attrName, interpolatedValue, tView, lView, sanitizer, namespace);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - 4, prefix, i0, i1, i2, suffix);
+        const 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;
 }
@@ -20303,11 +20323,9 @@ function ɵɵattributeInterpolate5(attrName, prefix, v0, i0, v1, i1, v2, i2, v3,
     const interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const 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);
+        const 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;
 }
@@ -20354,11 +20372,9 @@ function ɵɵattributeInterpolate6(attrName, prefix, v0, i0, v1, i1, v2, i2, v3,
     const interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const 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);
+        const 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;
 }
@@ -20407,11 +20423,9 @@ function ɵɵattributeInterpolate7(attrName, prefix, v0, i0, v1, i1, v2, i2, v3,
     const interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const 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);
+        const 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;
 }
@@ -20462,11 +20476,9 @@ function ɵɵattributeInterpolate8(attrName, prefix, v0, i0, v1, i1, v2, i2, v3,
     const interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix);
     if (interpolatedValue !== NO_CHANGE) {
         /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        /** @type {?} */
-        const 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);
+        const 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;
 }
@@ -20504,17 +20516,15 @@ function ɵɵattributeInterpolateV(attrName, values, sanitizer, namespace) {
     const interpolated = interpolationV(lView, values);
     if (interpolated !== NO_CHANGE) {
         /** @type {?} */
-        const tView = getTView();
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
-        elementAttributeInternal(nodeIndex, attrName, interpolated, tView, lView, sanitizer, namespace);
+        const tNode = getSelectedTNode();
+        elementAttributeInternal(tNode, lView, attrName, interpolated, sanitizer, namespace);
         if (ngDevMode) {
             /** @type {?} */
             const interpolationInBetween = [values[0]];
             for (let i = 2; i < values.length; i += 2) {
                 interpolationInBetween.push(values[i]);
             }
-            storePropertyBindingMetadata(tView.data, nodeIndex, 'attr.' + attrName, getBindingIndex() - interpolationInBetween.length + 1, ...interpolationInBetween);
+            storePropertyBindingMetadata(getTView().data, tNode, 'attr.' + attrName, getBindingIndex() - interpolationInBetween.length + 1, ...interpolationInBetween);
         }
     }
     return ɵɵattributeInterpolateV;
@@ -20909,12 +20919,12 @@ function ɵɵproperty(propName, value, sanitizer) {
     /** @type {?} */
     const bindingIndex = nextBindingIndex();
     if (bindingUpdated(lView, bindingIndex, value)) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, value, sanitizer);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, bindingIndex);
+        /** @type {?} */
+        const tNode = getSelectedTNode();
+        elementPropertyInternal(tView, tNode, lView, propName, value, lView[RENDERER], sanitizer, false);
+        ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
     }
     return ɵɵproperty;
 }
@@ -20934,9 +20944,7 @@ function setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value, isCla
     /** @type {?} */
     const property = isClassBased ? 'class' : 'style';
     // We support both 'class' and `className` hence the fallback.
-    /** @type {?} */
-    const stylingInputs = inputs[property] || (isClassBased && inputs['className']);
-    setInputsForProperty(tView, lView, stylingInputs, property, value);
+    setInputsForProperty(tView, lView, inputs[property], property, value);
 }
 
 /**
@@ -21972,12 +21980,12 @@ function ɵɵpropertyInterpolate1(propName, prefix, v0, suffix, sanitizer) {
     /** @type {?} */
     const interpolatedValue = interpolation1(lView, prefix, v0, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 1, prefix, suffix);
+        /** @type {?} */
+        const tNode = getSelectedTNode();
+        elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
+        ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 1, prefix, suffix);
     }
     return ɵɵpropertyInterpolate1;
 }
@@ -22017,12 +22025,12 @@ function ɵɵpropertyInterpolate2(propName, prefix, v0, i0, v1, suffix, sanitize
     /** @type {?} */
     const interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 2, prefix, i0, suffix);
+        /** @type {?} */
+        const 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;
 }
@@ -22065,13 +22073,12 @@ function ɵɵpropertyInterpolate3(propName, prefix, v0, i0, v1, i1, v2, suffix,
     /** @type {?} */
     const interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-        ngDevMode &&
-            storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 3, prefix, i0, i1, suffix);
+        /** @type {?} */
+        const 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;
 }
@@ -22116,13 +22123,13 @@ function ɵɵpropertyInterpolate4(propName, prefix, v0, i0, v1, i1, v2, i2, v3,
     /** @type {?} */
     const interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
+        /** @type {?} */
+        const 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;
 }
@@ -22169,13 +22176,13 @@ function ɵɵpropertyInterpolate5(propName, prefix, v0, i0, v1, i1, v2, i2, v3,
     /** @type {?} */
     const interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
+        /** @type {?} */
+        const 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;
 }
@@ -22224,12 +22231,13 @@ function ɵɵpropertyInterpolate6(propName, prefix, v0, i0, v1, i1, v2, i2, v3,
     /** @type {?} */
     const interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - 6, prefix, i0, i1, i2, i3, i4, suffix);
+        /** @type {?} */
+        const 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;
 }
@@ -22280,12 +22288,12 @@ function ɵɵpropertyInterpolate7(propName, prefix, v0, i0, v1, i1, v2, i2, v3,
     /** @type {?} */
     const interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const 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);
+        /** @type {?} */
+        const 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;
 }
@@ -22338,12 +22346,12 @@ function ɵɵpropertyInterpolate8(propName, prefix, v0, i0, v1, i1, v2, i2, v3,
     /** @type {?} */
     const interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const 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);
+        /** @type {?} */
+        const 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;
 }
@@ -22383,18 +22391,18 @@ function ɵɵpropertyInterpolateV(propName, values, sanitizer) {
     /** @type {?} */
     const interpolatedValue = interpolationV(lView, values);
     if (interpolatedValue !== NO_CHANGE) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, interpolatedValue, sanitizer);
+        /** @type {?} */
+        const tNode = getSelectedTNode();
+        elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
         if (ngDevMode) {
             /** @type {?} */
             const interpolationInBetween = [values[0]];
             for (let i = 2; i < values.length; i += 2) {
                 interpolationInBetween.push(values[i]);
             }
-            storePropertyBindingMetadata(tView.data, nodeIndex, propName, getBindingIndex() - interpolationInBetween.length + 1, ...interpolationInBetween);
+            storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - interpolationInBetween.length + 1, ...interpolationInBetween);
         }
     }
     return ɵɵpropertyInterpolateV;
@@ -25550,12 +25558,12 @@ function ɵɵhostProperty(propName, value, sanitizer) {
     /** @type {?} */
     const bindingIndex = nextBindingIndex();
     if (bindingUpdated(lView, bindingIndex, value)) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, value, sanitizer, true);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, bindingIndex);
+        /** @type {?} */
+        const tNode = getSelectedTNode();
+        elementPropertyInternal(tView, tNode, lView, propName, value, lView[RENDERER], sanitizer, true);
+        ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
     }
     return ɵɵhostProperty;
 }
@@ -25587,12 +25595,14 @@ function ɵɵupdateSyntheticHostBinding(propName, value, sanitizer) {
     /** @type {?} */
     const bindingIndex = nextBindingIndex();
     if (bindingUpdated(lView, bindingIndex, value)) {
-        /** @type {?} */
-        const nodeIndex = getSelectedIndex();
         /** @type {?} */
         const tView = getTView();
-        elementPropertyInternal(tView, lView, nodeIndex, propName, value, sanitizer, true, loadComponentRenderer);
-        ngDevMode && storePropertyBindingMetadata(tView.data, nodeIndex, propName, bindingIndex);
+        /** @type {?} */
+        const tNode = getSelectedTNode();
+        /** @type {?} */
+        const renderer = loadComponentRenderer(tNode, lView);
+        elementPropertyInternal(tView, tNode, lView, propName, value, renderer, sanitizer, true);
+        ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
     }
     return ɵɵupdateSyntheticHostBinding;
 }
@@ -26793,31 +26803,26 @@ const PRIVATE_PREFIX = '__ngOnChanges_';
  * static ɵcmp = defineComponent({
  *   ...
  *   inputs: {name: 'publicName'},
- *   features: [NgOnChangesFeature()]
+ *   features: [NgOnChangesFeature]
  * });
  * ```
  *
  * \@codeGenApi
- * @template T
- * @return {?}
- */
-function ɵɵNgOnChangesFeature() {
-    // This option ensures that the ngOnChanges lifecycle hook will be inherited
-    // from superclasses (in InheritDefinitionFeature).
-    ((/** @type {?} */ (NgOnChangesFeatureImpl))).ngInherit = true;
-    return NgOnChangesFeatureImpl;
-}
-/**
  * @template T
  * @param {?} definition
  * @return {?}
  */
-function NgOnChangesFeatureImpl(definition) {
+function ɵɵNgOnChangesFeature(definition) {
     if (definition.type.prototype.ngOnChanges) {
         definition.setInput = ngOnChangesSetInput;
         ((/** @type {?} */ (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
+((/** @type {?} */ (ɵɵNgOnChangesFeature))).ngInherit = true;
 /**
  * @return {?}
  */
@@ -28032,7 +28037,7 @@ if (false) {
  * \@publicApi
  * @type {?}
  */
-const VERSION = new Version('9.0.3');
+const VERSION = new Version('9.0.7');
 
 /**
  * @fileoverview added by tsickle
@@ -34802,14 +34807,20 @@ function i18nStartFirstPass(lView, tView, index, message, subTemplateIndex) {
             for (let j = 0; j < parts.length; j++) {
                 if (j & 1) {
                     // Odd indexes are ICU expressions
+                    /** @type {?} */
+                    const icuExpression = (/** @type {?} */ (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
                     /** @type {?} */
                     const icuNodeIndex = startIndex + i18nVarsCount++;
                     createOpCodes.push(COMMENT_MARKER, ngDevMode ? `ICU ${icuNodeIndex}` : '', icuNodeIndex, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
                     // Update codes for the ICU expression
                     /** @type {?} */
-                    const icuExpression = (/** @type {?} */ (parts[j]));
-                    /** @type {?} */
                     const mask = getBindingMask(icuExpression);
                     icuStart(icuExpressions, icuExpression, icuNodeIndex, icuNodeIndex);
                     // Since this is recursive, the last TIcu that was pushed is the one we want
@@ -35098,7 +35109,8 @@ function i18nEndFirstPass(tView, lView) {
         // Check if an element has any local refs and skip them
         /** @type {?} */
         const 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,
@@ -35212,7 +35224,7 @@ function readCreateOpCodes(index, createOpCodes, tView, lView) {
                     const attrValue = (/** @type {?} */ (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}"`);
@@ -35308,7 +35320,7 @@ function readUpdateOpCodes(updateOpCodes, icus, bindingsStartIndex, changeMask,
                                 const propName = (/** @type {?} */ (updateOpCodes[++j]));
                                 /** @type {?} */
                                 const sanitizeFn = (/** @type {?} */ (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);
@@ -35500,7 +35512,7 @@ function i18nAttributesFirstPass(lView, tView, index, values) {
                     // 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
                     /** @type {?} */
@@ -35992,10 +36004,14 @@ class NgModuleRef$1 extends NgModuleRef {
         const ngLocaleIdDef = getNgLocaleIdDef(ngModuleType);
         ngLocaleIdDef && setLocaleId(ngLocaleIdDef);
         this._bootstrapComponents = maybeUnwrapFn((/** @type {?} */ (ngModuleDef)).bootstrap);
-        this._r3Injector = (/** @type {?} */ (createInjector(ngModuleType, _parent, [
+        this._r3Injector = (/** @type {?} */ (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);
     }
     /**
@@ -36427,6 +36443,22 @@ function ɵɵpureFunction8(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, exp
 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`.
+ * @param {?} lView
+ * @param {?} returnValueIndex
+ * @return {?}
+ */
+function getPureFunctionReturnValue(lView, returnValueIndex) {
+    ngDevMode && assertDataInRange(lView, returnValueIndex);
+    /** @type {?} */
+    const 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.
@@ -36444,7 +36476,7 @@ function pureFunction1Internal(lView, bindingRoot, slotOffset, pureFn, exp, this
     const 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
@@ -36464,7 +36496,7 @@ function pureFunction2Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp
     const 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
@@ -36485,7 +36517,7 @@ function pureFunction3Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp
     const 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
@@ -36508,7 +36540,7 @@ function pureFunction4Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp
     const 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.
@@ -36534,7 +36566,7 @@ function pureFunctionVInternal(lView, bindingRoot, slotOffset, pureFn, exps, thi
         bindingUpdated(lView, bindingIndex++, exps[i]) && (different = true);
     }
     return different ? updateBinding(lView, bindingIndex, pureFn.apply(thisArg, exps)) :
-        getBinding(lView, bindingIndex);
+        getPureFunctionReturnValue(lView, bindingIndex);
 }
 
 /**
@@ -37755,7 +37787,7 @@ const unusedValueExportToPlacateAjd$8 = 1;
  * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /** @type {?} */
-const unusedValueToPlacateAjd$2 = unusedValueExportToPlacateAjd$7 + unusedValueExportToPlacateAjd$2 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$8;
+const unusedValueToPlacateAjd$2 = unusedValueExportToPlacateAjd$7 + unusedValueExportToPlacateAjd$3 + unusedValueExportToPlacateAjd$4 + unusedValueExportToPlacateAjd$8;
 /**
  * @template T
  */
@@ -38278,10 +38310,7 @@ function collectQueryResults(tView, lView, queryIndex, result) {
             /** @type {?} */
             const tNodeIdx = tQueryMatches[i];
             if (tNodeIdx > 0) {
-                /** @type {?} */
-                const viewResult = lViewResults[i / 2];
-                ngDevMode && assertDefined(viewResult, 'materialized query result should be defined');
-                result.push((/** @type {?} */ (viewResult)));
+                result.push((/** @type {?} */ (lViewResults[i / 2])));
             }
             else {
                 /** @type {?} */
@@ -39285,23 +39314,6 @@ function transitiveScopesFor(moduleType) {
             pipes: new Set(),
         },
     };
-    maybeUnwrapFn(def.declarations).forEach((/**
-     * @param {?} declared
-     * @return {?}
-     */
-    declared => {
-        /** @type {?} */
-        const declaredWithDefs = (/** @type {?} */ (declared));
-        if (getPipeDef(declaredWithDefs)) {
-            scopes.compilation.pipes.add(declared);
-        }
-        else {
-            // Either declared has a ɵcmp or ɵdir, or it's a component which hasn't
-            // had its template compiled yet. In either case, it gets added to the compilation's
-            // directives.
-            scopes.compilation.directives.add(declared);
-        }
-    }));
     maybeUnwrapFn(def.imports).forEach((/**
      * @template I
      * @param {?} imported
@@ -39328,6 +39340,23 @@ function transitiveScopesFor(moduleType) {
          */
         entry => scopes.compilation.pipes.add(entry)));
     }));
+    maybeUnwrapFn(def.declarations).forEach((/**
+     * @param {?} declared
+     * @return {?}
+     */
+    declared => {
+        /** @type {?} */
+        const declaredWithDefs = (/** @type {?} */ (declared));
+        if (getPipeDef(declaredWithDefs)) {
+            scopes.compilation.pipes.add(declared);
+        }
+        else {
+            // Either declared has a ɵcmp or ɵdir, or it's a component which hasn't
+            // had its template compiled yet. In either case, it gets added to the compilation's
+            // directives.
+            scopes.compilation.directives.add(declared);
+        }
+    }));
     maybeUnwrapFn(def.exports).forEach((/**
      * @template E
      * @param {?} exported
@@ -47847,5 +47876,5 @@ if (ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANALYZE_FOR_ENTRY_COMPONENTS, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory, ComponentFactoryResolver, ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode$1 as DebugNode, DefaultIterableDiffer, Directive, ElementRef, EmbeddedViewRef, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID$1 as LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory, NgModuleFactoryLoader, NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, SystemJsNgModuleLoader, SystemJsNgModuleLoaderConfig, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef$1 as ViewRef, WrappedValue, asNativeElements, assertPlatform, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, enableProdMode, forwardRef, getDebugNode$1 as getDebugNode, getModuleFactory, getPlatform, inject, isDevMode, platformCore, resolveForwardRef, setTestabilityGetter, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER, ChangeDetectorStatus as ɵChangeDetectorStatus, CodegenComponentFactoryResolver as ɵCodegenComponentFactoryResolver, Compiler_compileModuleAndAllComponentsAsync__POST_R3__ as ɵCompiler_compileModuleAndAllComponentsAsync__POST_R3__, Compiler_compileModuleAndAllComponentsSync__POST_R3__ as ɵCompiler_compileModuleAndAllComponentsSync__POST_R3__, Compiler_compileModuleAsync__POST_R3__ as ɵCompiler_compileModuleAsync__POST_R3__, Compiler_compileModuleSync__POST_R3__ as ɵCompiler_compileModuleSync__POST_R3__, ComponentFactory as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, EMPTY_ARRAY$4 as ɵEMPTY_ARRAY, EMPTY_MAP as ɵEMPTY_MAP, INJECTOR_IMPL__POST_R3__ as ɵINJECTOR_IMPL__POST_R3__, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory$1 as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory$1 as ɵRender3ComponentFactory, ComponentRef$1 as ɵRender3ComponentRef, NgModuleRef$1 as ɵRender3NgModuleRef, SWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__ as ɵSWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__, SWITCH_COMPILE_COMPONENT__POST_R3__ as ɵSWITCH_COMPILE_COMPONENT__POST_R3__, SWITCH_COMPILE_DIRECTIVE__POST_R3__ as ɵSWITCH_COMPILE_DIRECTIVE__POST_R3__, SWITCH_COMPILE_INJECTABLE__POST_R3__ as ɵSWITCH_COMPILE_INJECTABLE__POST_R3__, SWITCH_COMPILE_NGMODULE__POST_R3__ as ɵSWITCH_COMPILE_NGMODULE__POST_R3__, SWITCH_COMPILE_PIPE__POST_R3__ as ɵSWITCH_COMPILE_PIPE__POST_R3__, SWITCH_ELEMENT_REF_FACTORY__POST_R3__ as ɵSWITCH_ELEMENT_REF_FACTORY__POST_R3__, SWITCH_IVY_ENABLED__POST_R3__ as ɵSWITCH_IVY_ENABLED__POST_R3__, SWITCH_RENDERER2_FACTORY__POST_R3__ as ɵSWITCH_RENDERER2_FACTORY__POST_R3__, SWITCH_TEMPLATE_REF_FACTORY__POST_R3__ as ɵSWITCH_TEMPLATE_REF_FACTORY__POST_R3__, SWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__ as ɵSWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeStyle as ɵ_sanitizeStyle, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, anchorDef as ɵand, isForwardRef as ɵangular_packages_core_core_a, injectInjectorOnly as ɵangular_packages_core_core_b, getLView as ɵangular_packages_core_core_ba, getPreviousOrParentTNode as ɵangular_packages_core_core_bb, getBindingRoot as ɵangular_packages_core_core_bc, nextContextImpl as ɵangular_packages_core_core_bd, pureFunction1Internal as ɵangular_packages_core_core_bf, pureFunction2Internal as ɵangular_packages_core_core_bg, pureFunction3Internal as ɵangular_packages_core_core_bh, pureFunction4Internal as ɵangular_packages_core_core_bi, pureFunctionVInternal as ɵangular_packages_core_core_bj, getUrlSanitizer as ɵangular_packages_core_core_bk, makeParamDecorator as ɵangular_packages_core_core_bl, makePropDecorator as ɵangular_packages_core_core_bm, getClosureSafeProperty as ɵangular_packages_core_core_bn, noSideEffects as ɵangular_packages_core_core_bp, getRootContext as ɵangular_packages_core_core_bq, NullInjector as ɵangular_packages_core_core_c, ReflectiveInjector_ as ɵangular_packages_core_core_d, ReflectiveDependency as ɵangular_packages_core_core_e, resolveReflectiveProviders as ɵangular_packages_core_core_f, _appIdRandomProviderFactory as ɵangular_packages_core_core_g, createElementRef as ɵangular_packages_core_core_h, createTemplateRef as ɵangular_packages_core_core_i, getModuleFactory__PRE_R3__ as ɵangular_packages_core_core_j, DebugNode__PRE_R3__ as ɵangular_packages_core_core_k, DebugElement__PRE_R3__ as ɵangular_packages_core_core_l, getDebugNodeR2__PRE_R3__ as ɵangular_packages_core_core_m, DefaultIterableDifferFactory as ɵangular_packages_core_core_n, DefaultKeyValueDifferFactory as ɵangular_packages_core_core_o, _iterableDiffersFactory as ɵangular_packages_core_core_p, _keyValueDiffersFactory as ɵangular_packages_core_core_q, _localeFactory as ɵangular_packages_core_core_r, APPLICATION_MODULE_PROVIDERS as ɵangular_packages_core_core_s, zoneSchedulerFactory as ɵangular_packages_core_core_t, USD_CURRENCY_CODE as ɵangular_packages_core_core_u, _def as ɵangular_packages_core_core_v, DebugContext as ɵangular_packages_core_core_w, SCHEDULER as ɵangular_packages_core_core_x, injectAttributeImpl as ɵangular_packages_core_core_y, instructionState as ɵangular_packages_core_core_z, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, createComponentFactory as ɵccf, clearOverrides as ɵclearOverrides, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, createNgModuleFactory as ɵcmf, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory__POST_R3__ as ɵcompileNgModuleFactory__POST_R3__, compilePipe as ɵcompilePipe, createInjector as ɵcreateInjector, createRendererType2 as ɵcrt, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual$1 as ɵdevModeEqual, directiveDef as ɵdid, elementDef as ɵeld, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, getComponentViewDefinitionFactory as ɵgetComponentViewDefinitionFactory, getDebugNodeR2 as ɵgetDebugNodeR2, getDebugNode__POST_R3__ as ɵgetDebugNode__POST_R3__, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getModuleFactory__POST_R3__ as ɵgetModuleFactory__POST_R3__, getSanitizationBypassType as ɵgetSanitizationBypassType, _global as ɵglobal, initServicesIfNeeded as ɵinitServicesIfNeeded, inlineInterpolate as ɵinlineInterpolate, interpolate as ɵinterpolate, isBoundToModule__POST_R3__ as ɵisBoundToModule__POST_R3__, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy, isListLikeIterable$1 as ɵisListLikeIterable, isObservable as ɵisObservable, isPromise as ɵisPromise, ivyEnabled as ɵivyEnabled, looseIdentical as ɵlooseIdentical, makeDecorator as ɵmakeDecorator, markDirty as ɵmarkDirty, moduleDef as ɵmod, moduleProvideDef as ɵmpd, ngContentDef as ɵncd, nodeValue as ɵnov, overrideComponentView as ɵoverrideComponentView, overrideProvider as ɵoverrideProvider, pureArrayDef as ɵpad, patchComponentDefWithScope as ɵpatchComponentDefWithScope, pipeDef as ɵpid, pureObjectDef as ɵpod, purePipeDef as ɵppd, providerDef as ɵprd, publishDefaultGlobalUtils as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, queryDef as ɵqud, registerLocaleData as ɵregisterLocaleData, registerModuleFactory as ɵregisterModuleFactory, registerNgModuleType as ɵregisterNgModuleType, renderComponent$1 as ɵrenderComponent, resetCompiledComponents as ɵresetCompiledComponents, resolveComponentResources as ɵresolveComponentResources, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, store as ɵstore, stringify as ɵstringify, textDef as ɵted, transitiveScopesFor as ɵtransitiveScopesFor, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapValue as ɵunv, unwrapSafeValue as ɵunwrapSafeValue, viewDef as ɵvid, whenRendered as ɵwhenRendered, ɵɵCopyDefinitionFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentHostSyntheticListener, ɵɵcontainer, ɵɵcontainerRefreshEnd, ɵɵcontainerRefreshStart, ɵɵcontentQuery, ɵɵdefaultStyleSanitizer, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵembeddedViewEnd, ɵɵembeddedViewStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetFactoryOf, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinjectPipeChangeDetectorRef, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵselect, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstaticContentQuery, ɵɵstaticViewQuery, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵstyleSanitizer, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵupdateSyntheticHostBinding, ɵɵviewQuery };
+export { ANALYZE_FOR_ENTRY_COMPONENTS, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory, ComponentFactoryResolver, ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode$1 as DebugNode, DefaultIterableDiffer, Directive, ElementRef, EmbeddedViewRef, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID$1 as LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory, NgModuleFactoryLoader, NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, SystemJsNgModuleLoader, SystemJsNgModuleLoaderConfig, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef$1 as ViewRef, WrappedValue, asNativeElements, assertPlatform, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, enableProdMode, forwardRef, getDebugNode$1 as getDebugNode, getModuleFactory, getPlatform, inject, isDevMode, platformCore, resolveForwardRef, setTestabilityGetter, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER, ChangeDetectorStatus as ɵChangeDetectorStatus, CodegenComponentFactoryResolver as ɵCodegenComponentFactoryResolver, Compiler_compileModuleAndAllComponentsAsync__POST_R3__ as ɵCompiler_compileModuleAndAllComponentsAsync__POST_R3__, Compiler_compileModuleAndAllComponentsSync__POST_R3__ as ɵCompiler_compileModuleAndAllComponentsSync__POST_R3__, Compiler_compileModuleAsync__POST_R3__ as ɵCompiler_compileModuleAsync__POST_R3__, Compiler_compileModuleSync__POST_R3__ as ɵCompiler_compileModuleSync__POST_R3__, ComponentFactory as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, EMPTY_ARRAY$4 as ɵEMPTY_ARRAY, EMPTY_MAP as ɵEMPTY_MAP, INJECTOR_IMPL__POST_R3__ as ɵINJECTOR_IMPL__POST_R3__, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory$1 as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory$1 as ɵRender3ComponentFactory, ComponentRef$1 as ɵRender3ComponentRef, NgModuleRef$1 as ɵRender3NgModuleRef, SWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__ as ɵSWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__, SWITCH_COMPILE_COMPONENT__POST_R3__ as ɵSWITCH_COMPILE_COMPONENT__POST_R3__, SWITCH_COMPILE_DIRECTIVE__POST_R3__ as ɵSWITCH_COMPILE_DIRECTIVE__POST_R3__, SWITCH_COMPILE_INJECTABLE__POST_R3__ as ɵSWITCH_COMPILE_INJECTABLE__POST_R3__, SWITCH_COMPILE_NGMODULE__POST_R3__ as ɵSWITCH_COMPILE_NGMODULE__POST_R3__, SWITCH_COMPILE_PIPE__POST_R3__ as ɵSWITCH_COMPILE_PIPE__POST_R3__, SWITCH_ELEMENT_REF_FACTORY__POST_R3__ as ɵSWITCH_ELEMENT_REF_FACTORY__POST_R3__, SWITCH_IVY_ENABLED__POST_R3__ as ɵSWITCH_IVY_ENABLED__POST_R3__, SWITCH_RENDERER2_FACTORY__POST_R3__ as ɵSWITCH_RENDERER2_FACTORY__POST_R3__, SWITCH_TEMPLATE_REF_FACTORY__POST_R3__ as ɵSWITCH_TEMPLATE_REF_FACTORY__POST_R3__, SWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__ as ɵSWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeStyle as ɵ_sanitizeStyle, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, anchorDef as ɵand, isForwardRef as ɵangular_packages_core_core_a, injectInjectorOnly as ɵangular_packages_core_core_b, getLView as ɵangular_packages_core_core_ba, getPreviousOrParentTNode as ɵangular_packages_core_core_bb, getBindingRoot as ɵangular_packages_core_core_bc, nextContextImpl as ɵangular_packages_core_core_bd, pureFunction1Internal as ɵangular_packages_core_core_bf, pureFunction2Internal as ɵangular_packages_core_core_bg, pureFunction3Internal as ɵangular_packages_core_core_bh, pureFunction4Internal as ɵangular_packages_core_core_bi, pureFunctionVInternal as ɵangular_packages_core_core_bj, getUrlSanitizer as ɵangular_packages_core_core_bk, makeParamDecorator as ɵangular_packages_core_core_bl, makePropDecorator as ɵangular_packages_core_core_bm, getClosureSafeProperty as ɵangular_packages_core_core_bn, noSideEffects as ɵangular_packages_core_core_bo, getRootContext as ɵangular_packages_core_core_bq, NullInjector as ɵangular_packages_core_core_c, ReflectiveInjector_ as ɵangular_packages_core_core_d, ReflectiveDependency as ɵangular_packages_core_core_e, resolveReflectiveProviders as ɵangular_packages_core_core_f, _appIdRandomProviderFactory as ɵangular_packages_core_core_g, createElementRef as ɵangular_packages_core_core_h, createTemplateRef as ɵangular_packages_core_core_i, getModuleFactory__PRE_R3__ as ɵangular_packages_core_core_j, DebugNode__PRE_R3__ as ɵangular_packages_core_core_k, DebugElement__PRE_R3__ as ɵangular_packages_core_core_l, getDebugNodeR2__PRE_R3__ as ɵangular_packages_core_core_m, DefaultIterableDifferFactory as ɵangular_packages_core_core_n, DefaultKeyValueDifferFactory as ɵangular_packages_core_core_o, _iterableDiffersFactory as ɵangular_packages_core_core_p, _keyValueDiffersFactory as ɵangular_packages_core_core_q, _localeFactory as ɵangular_packages_core_core_r, APPLICATION_MODULE_PROVIDERS as ɵangular_packages_core_core_s, zoneSchedulerFactory as ɵangular_packages_core_core_t, USD_CURRENCY_CODE as ɵangular_packages_core_core_u, _def as ɵangular_packages_core_core_v, DebugContext as ɵangular_packages_core_core_w, SCHEDULER as ɵangular_packages_core_core_x, injectAttributeImpl as ɵangular_packages_core_core_y, instructionState as ɵangular_packages_core_core_z, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, createComponentFactory as ɵccf, clearOverrides as ɵclearOverrides, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, createNgModuleFactory as ɵcmf, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory__POST_R3__ as ɵcompileNgModuleFactory__POST_R3__, compilePipe as ɵcompilePipe, createInjector as ɵcreateInjector, createRendererType2 as ɵcrt, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual$1 as ɵdevModeEqual, directiveDef as ɵdid, elementDef as ɵeld, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, getComponentViewDefinitionFactory as ɵgetComponentViewDefinitionFactory, getDebugNodeR2 as ɵgetDebugNodeR2, getDebugNode__POST_R3__ as ɵgetDebugNode__POST_R3__, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getModuleFactory__POST_R3__ as ɵgetModuleFactory__POST_R3__, getSanitizationBypassType as ɵgetSanitizationBypassType, _global as ɵglobal, initServicesIfNeeded as ɵinitServicesIfNeeded, inlineInterpolate as ɵinlineInterpolate, interpolate as ɵinterpolate, isBoundToModule__POST_R3__ as ɵisBoundToModule__POST_R3__, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy, isListLikeIterable$1 as ɵisListLikeIterable, isObservable as ɵisObservable, isPromise as ɵisPromise, ivyEnabled as ɵivyEnabled, looseIdentical as ɵlooseIdentical, makeDecorator as ɵmakeDecorator, markDirty as ɵmarkDirty, moduleDef as ɵmod, moduleProvideDef as ɵmpd, ngContentDef as ɵncd, nodeValue as ɵnov, overrideComponentView as ɵoverrideComponentView, overrideProvider as ɵoverrideProvider, pureArrayDef as ɵpad, patchComponentDefWithScope as ɵpatchComponentDefWithScope, pipeDef as ɵpid, pureObjectDef as ɵpod, purePipeDef as ɵppd, providerDef as ɵprd, publishDefaultGlobalUtils as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, queryDef as ɵqud, registerLocaleData as ɵregisterLocaleData, registerModuleFactory as ɵregisterModuleFactory, registerNgModuleType as ɵregisterNgModuleType, renderComponent$1 as ɵrenderComponent, resetCompiledComponents as ɵresetCompiledComponents, resolveComponentResources as ɵresolveComponentResources, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, store as ɵstore, stringify as ɵstringify, textDef as ɵted, transitiveScopesFor as ɵtransitiveScopesFor, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapValue as ɵunv, unwrapSafeValue as ɵunwrapSafeValue, viewDef as ɵvid, whenRendered as ɵwhenRendered, ɵɵCopyDefinitionFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentHostSyntheticListener, ɵɵcontainer, ɵɵcontainerRefreshEnd, ɵɵcontainerRefreshStart, ɵɵcontentQuery, ɵɵdefaultStyleSanitizer, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵembeddedViewEnd, ɵɵembeddedViewStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetFactoryOf, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinjectPipeChangeDetectorRef, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵselect, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstaticContentQuery, ɵɵstaticViewQuery, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵstyleSanitizer, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵupdateSyntheticHostBinding, ɵɵviewQuery };
 //# sourceMappingURL=core.js.map