@angular/compiler 14.0.0-next.0 → 14.0.0-next.11

package/fesm2015/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v14.0.0-next.0
+ * @license Angular v14.0.0-next.11
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -224,11 +224,11 @@ class CssSelector {
                 const prefix = match[3 /* PREFIX */];
                 if (prefix === '#') {
                     // #hash
-                    current.addAttribute('id', tag.substr(1));
+                    current.addAttribute('id', tag.slice(1));
                 }
                 else if (prefix === '.') {
                     // Class
-                    current.addClassName(tag.substr(1));
+                    current.addClassName(tag.slice(1));
                 }
                 else {
                     // Element
@@ -2737,206 +2737,208 @@ function isLongStringLiteral(expr) {
  * 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
  */
-const CORE$1 = '@angular/core';
-class Identifiers$1 {
+const CORE = '@angular/core';
+class Identifiers {
 }
 /* Methods */
-Identifiers$1.NEW_METHOD = 'factory';
-Identifiers$1.TRANSFORM_METHOD = 'transform';
-Identifiers$1.PATCH_DEPS = 'patchedDeps';
-Identifiers$1.core = { name: null, moduleName: CORE$1 };
+Identifiers.NEW_METHOD = 'factory';
+Identifiers.TRANSFORM_METHOD = 'transform';
+Identifiers.PATCH_DEPS = 'patchedDeps';
+Identifiers.core = { name: null, moduleName: CORE };
 /* Instructions */
-Identifiers$1.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE$1 };
-Identifiers$1.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE$1 };
-Identifiers$1.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE$1 };
-Identifiers$1.element = { name: 'ɵɵelement', moduleName: CORE$1 };
-Identifiers$1.elementStart = { name: 'ɵɵelementStart', moduleName: CORE$1 };
-Identifiers$1.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE$1 };
-Identifiers$1.advance = { name: 'ɵɵadvance', moduleName: CORE$1 };
-Identifiers$1.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE$1 };
-Identifiers$1.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE$1 };
-Identifiers$1.attribute = { name: 'ɵɵattribute', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE$1 };
-Identifiers$1.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE$1 };
-Identifiers$1.classProp = { name: 'ɵɵclassProp', moduleName: CORE$1 };
-Identifiers$1.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE$1 };
-Identifiers$1.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE$1 };
-Identifiers$1.elementContainer = { name: 'ɵɵelementContainer', moduleName: CORE$1 };
-Identifiers$1.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate1 = { name: 'ɵɵstyleMapInterpolate1', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate2 = { name: 'ɵɵstyleMapInterpolate2', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate3 = { name: 'ɵɵstyleMapInterpolate3', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate4 = { name: 'ɵɵstyleMapInterpolate4', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate5 = { name: 'ɵɵstyleMapInterpolate5', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate6 = { name: 'ɵɵstyleMapInterpolate6', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate7 = { name: 'ɵɵstyleMapInterpolate7', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolate8 = { name: 'ɵɵstyleMapInterpolate8', moduleName: CORE$1 };
-Identifiers$1.styleMapInterpolateV = { name: 'ɵɵstyleMapInterpolateV', moduleName: CORE$1 };
-Identifiers$1.classMap = { name: 'ɵɵclassMap', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate1 = { name: 'ɵɵclassMapInterpolate1', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate2 = { name: 'ɵɵclassMapInterpolate2', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate3 = { name: 'ɵɵclassMapInterpolate3', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate4 = { name: 'ɵɵclassMapInterpolate4', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate5 = { name: 'ɵɵclassMapInterpolate5', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate6 = { name: 'ɵɵclassMapInterpolate6', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate7 = { name: 'ɵɵclassMapInterpolate7', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolate8 = { name: 'ɵɵclassMapInterpolate8', moduleName: CORE$1 };
-Identifiers$1.classMapInterpolateV = { name: 'ɵɵclassMapInterpolateV', moduleName: CORE$1 };
-Identifiers$1.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate1 = { name: 'ɵɵstylePropInterpolate1', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate2 = { name: 'ɵɵstylePropInterpolate2', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate3 = { name: 'ɵɵstylePropInterpolate3', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate4 = { name: 'ɵɵstylePropInterpolate4', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate5 = { name: 'ɵɵstylePropInterpolate5', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate6 = { name: 'ɵɵstylePropInterpolate6', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE$1 };
-Identifiers$1.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE$1 };
-Identifiers$1.nextContext = { name: 'ɵɵnextContext', moduleName: CORE$1 };
-Identifiers$1.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE$1 };
-Identifiers$1.text = { name: 'ɵɵtext', moduleName: CORE$1 };
-Identifiers$1.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE$1 };
-Identifiers$1.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE$1 };
-Identifiers$1.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE$1 };
-Identifiers$1.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE$1 };
-Identifiers$1.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE$1 };
-Identifiers$1.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE$1 };
-Identifiers$1.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE$1 };
-Identifiers$1.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE$1 };
-Identifiers$1.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE$1 };
-Identifiers$1.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE$1 };
-Identifiers$1.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE$1 };
-Identifiers$1.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE$1 };
-Identifiers$1.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE$1 };
-Identifiers$1.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE$1 };
-Identifiers$1.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE$1 };
-Identifiers$1.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE$1 };
-Identifiers$1.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE$1 };
-Identifiers$1.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE$1 };
-Identifiers$1.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE$1 };
-Identifiers$1.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE$1 };
-Identifiers$1.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE$1 };
-Identifiers$1.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE$1 };
-Identifiers$1.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE$1 };
-Identifiers$1.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE$1 };
-Identifiers$1.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE$1 };
-Identifiers$1.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE$1 };
-Identifiers$1.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE$1 };
-Identifiers$1.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE$1 };
-Identifiers$1.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE$1 };
-Identifiers$1.hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE$1 };
-Identifiers$1.property = { name: 'ɵɵproperty', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE$1 };
-Identifiers$1.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE$1 };
-Identifiers$1.i18n = { name: 'ɵɵi18n', moduleName: CORE$1 };
-Identifiers$1.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE$1 };
-Identifiers$1.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE$1 };
-Identifiers$1.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE$1 };
-Identifiers$1.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE$1 };
-Identifiers$1.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE$1 };
-Identifiers$1.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE$1 };
-Identifiers$1.pipe = { name: 'ɵɵpipe', moduleName: CORE$1 };
-Identifiers$1.projection = { name: 'ɵɵprojection', moduleName: CORE$1 };
-Identifiers$1.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE$1 };
-Identifiers$1.reference = { name: 'ɵɵreference', moduleName: CORE$1 };
-Identifiers$1.inject = { name: 'ɵɵinject', moduleName: CORE$1 };
-Identifiers$1.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE$1 };
-Identifiers$1.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE$1 };
-Identifiers$1.invalidFactory = { name: 'ɵɵinvalidFactory', moduleName: CORE$1 };
-Identifiers$1.invalidFactoryDep = { name: 'ɵɵinvalidFactoryDep', moduleName: CORE$1 };
-Identifiers$1.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE$1 };
-Identifiers$1.forwardRef = { name: 'forwardRef', moduleName: CORE$1 };
-Identifiers$1.resolveForwardRef = { name: 'resolveForwardRef', moduleName: CORE$1 };
-Identifiers$1.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE$1 };
-Identifiers$1.declareInjectable = { name: 'ɵɵngDeclareInjectable', moduleName: CORE$1 };
-Identifiers$1.InjectableDeclaration = { name: 'ɵɵInjectableDeclaration', moduleName: CORE$1 };
-Identifiers$1.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE$1 };
-Identifiers$1.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE$1 };
-Identifiers$1.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE$1 };
-Identifiers$1.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE$1 };
-Identifiers$1.declareComponent = { name: 'ɵɵngDeclareComponent', moduleName: CORE$1 };
-Identifiers$1.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE$1 };
-Identifiers$1.ChangeDetectionStrategy = {
+Identifiers.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE };
+Identifiers.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE };
+Identifiers.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE };
+Identifiers.element = { name: 'ɵɵelement', moduleName: CORE };
+Identifiers.elementStart = { name: 'ɵɵelementStart', moduleName: CORE };
+Identifiers.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE };
+Identifiers.advance = { name: 'ɵɵadvance', moduleName: CORE };
+Identifiers.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE };
+Identifiers.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE };
+Identifiers.attribute = { name: 'ɵɵattribute', moduleName: CORE };
+Identifiers.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE };
+Identifiers.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE };
+Identifiers.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE };
+Identifiers.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE };
+Identifiers.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE };
+Identifiers.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE };
+Identifiers.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE };
+Identifiers.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE };
+Identifiers.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE };
+Identifiers.classProp = { name: 'ɵɵclassProp', moduleName: CORE };
+Identifiers.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE };
+Identifiers.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE };
+Identifiers.elementContainer = { name: 'ɵɵelementContainer', moduleName: CORE };
+Identifiers.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE };
+Identifiers.styleMapInterpolate1 = { name: 'ɵɵstyleMapInterpolate1', moduleName: CORE };
+Identifiers.styleMapInterpolate2 = { name: 'ɵɵstyleMapInterpolate2', moduleName: CORE };
+Identifiers.styleMapInterpolate3 = { name: 'ɵɵstyleMapInterpolate3', moduleName: CORE };
+Identifiers.styleMapInterpolate4 = { name: 'ɵɵstyleMapInterpolate4', moduleName: CORE };
+Identifiers.styleMapInterpolate5 = { name: 'ɵɵstyleMapInterpolate5', moduleName: CORE };
+Identifiers.styleMapInterpolate6 = { name: 'ɵɵstyleMapInterpolate6', moduleName: CORE };
+Identifiers.styleMapInterpolate7 = { name: 'ɵɵstyleMapInterpolate7', moduleName: CORE };
+Identifiers.styleMapInterpolate8 = { name: 'ɵɵstyleMapInterpolate8', moduleName: CORE };
+Identifiers.styleMapInterpolateV = { name: 'ɵɵstyleMapInterpolateV', moduleName: CORE };
+Identifiers.classMap = { name: 'ɵɵclassMap', moduleName: CORE };
+Identifiers.classMapInterpolate1 = { name: 'ɵɵclassMapInterpolate1', moduleName: CORE };
+Identifiers.classMapInterpolate2 = { name: 'ɵɵclassMapInterpolate2', moduleName: CORE };
+Identifiers.classMapInterpolate3 = { name: 'ɵɵclassMapInterpolate3', moduleName: CORE };
+Identifiers.classMapInterpolate4 = { name: 'ɵɵclassMapInterpolate4', moduleName: CORE };
+Identifiers.classMapInterpolate5 = { name: 'ɵɵclassMapInterpolate5', moduleName: CORE };
+Identifiers.classMapInterpolate6 = { name: 'ɵɵclassMapInterpolate6', moduleName: CORE };
+Identifiers.classMapInterpolate7 = { name: 'ɵɵclassMapInterpolate7', moduleName: CORE };
+Identifiers.classMapInterpolate8 = { name: 'ɵɵclassMapInterpolate8', moduleName: CORE };
+Identifiers.classMapInterpolateV = { name: 'ɵɵclassMapInterpolateV', moduleName: CORE };
+Identifiers.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE };
+Identifiers.stylePropInterpolate1 = { name: 'ɵɵstylePropInterpolate1', moduleName: CORE };
+Identifiers.stylePropInterpolate2 = { name: 'ɵɵstylePropInterpolate2', moduleName: CORE };
+Identifiers.stylePropInterpolate3 = { name: 'ɵɵstylePropInterpolate3', moduleName: CORE };
+Identifiers.stylePropInterpolate4 = { name: 'ɵɵstylePropInterpolate4', moduleName: CORE };
+Identifiers.stylePropInterpolate5 = { name: 'ɵɵstylePropInterpolate5', moduleName: CORE };
+Identifiers.stylePropInterpolate6 = { name: 'ɵɵstylePropInterpolate6', moduleName: CORE };
+Identifiers.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE };
+Identifiers.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE };
+Identifiers.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE };
+Identifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE };
+Identifiers.resetView = { name: 'ɵɵresetView', moduleName: CORE };
+Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE };
+Identifiers.text = { name: 'ɵɵtext', moduleName: CORE };
+Identifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE };
+Identifiers.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE };
+Identifiers.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE };
+Identifiers.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE };
+Identifiers.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE };
+Identifiers.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE };
+Identifiers.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE };
+Identifiers.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE };
+Identifiers.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE };
+Identifiers.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE };
+Identifiers.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE };
+Identifiers.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE };
+Identifiers.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE };
+Identifiers.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE };
+Identifiers.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE };
+Identifiers.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE };
+Identifiers.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE };
+Identifiers.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE };
+Identifiers.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE };
+Identifiers.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE };
+Identifiers.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE };
+Identifiers.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE };
+Identifiers.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE };
+Identifiers.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE };
+Identifiers.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE };
+Identifiers.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE };
+Identifiers.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE };
+Identifiers.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE };
+Identifiers.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE };
+Identifiers.hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE };
+Identifiers.property = { name: 'ɵɵproperty', moduleName: CORE };
+Identifiers.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE };
+Identifiers.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE };
+Identifiers.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE };
+Identifiers.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE };
+Identifiers.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE };
+Identifiers.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE };
+Identifiers.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE };
+Identifiers.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE };
+Identifiers.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE };
+Identifiers.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE };
+Identifiers.i18n = { name: 'ɵɵi18n', moduleName: CORE };
+Identifiers.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE };
+Identifiers.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE };
+Identifiers.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE };
+Identifiers.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE };
+Identifiers.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE };
+Identifiers.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE };
+Identifiers.pipe = { name: 'ɵɵpipe', moduleName: CORE };
+Identifiers.projection = { name: 'ɵɵprojection', moduleName: CORE };
+Identifiers.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE };
+Identifiers.reference = { name: 'ɵɵreference', moduleName: CORE };
+Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE };
+Identifiers.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE };
+Identifiers.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE };
+Identifiers.invalidFactory = { name: 'ɵɵinvalidFactory', moduleName: CORE };
+Identifiers.invalidFactoryDep = { name: 'ɵɵinvalidFactoryDep', moduleName: CORE };
+Identifiers.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE };
+Identifiers.forwardRef = { name: 'forwardRef', moduleName: CORE };
+Identifiers.resolveForwardRef = { name: 'resolveForwardRef', moduleName: CORE };
+Identifiers.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE };
+Identifiers.declareInjectable = { name: 'ɵɵngDeclareInjectable', moduleName: CORE };
+Identifiers.InjectableDeclaration = { name: 'ɵɵInjectableDeclaration', moduleName: CORE };
+Identifiers.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE };
+Identifiers.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE };
+Identifiers.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE };
+Identifiers.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE };
+Identifiers.declareComponent = { name: 'ɵɵngDeclareComponent', moduleName: CORE };
+Identifiers.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE };
+Identifiers.ChangeDetectionStrategy = {
     name: 'ChangeDetectionStrategy',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
-Identifiers$1.ViewEncapsulation = {
+Identifiers.ViewEncapsulation = {
     name: 'ViewEncapsulation',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
-Identifiers$1.ComponentDeclaration = {
+Identifiers.ComponentDeclaration = {
     name: 'ɵɵComponentDeclaration',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
-Identifiers$1.FactoryDeclaration = {
+Identifiers.FactoryDeclaration = {
     name: 'ɵɵFactoryDeclaration',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
-Identifiers$1.declareFactory = { name: 'ɵɵngDeclareFactory', moduleName: CORE$1 };
-Identifiers$1.FactoryTarget = { name: 'ɵɵFactoryTarget', moduleName: CORE$1 };
-Identifiers$1.defineDirective = { name: 'ɵɵdefineDirective', moduleName: CORE$1 };
-Identifiers$1.declareDirective = { name: 'ɵɵngDeclareDirective', moduleName: CORE$1 };
-Identifiers$1.DirectiveDeclaration = {
+Identifiers.declareFactory = { name: 'ɵɵngDeclareFactory', moduleName: CORE };
+Identifiers.FactoryTarget = { name: 'ɵɵFactoryTarget', moduleName: CORE };
+Identifiers.defineDirective = { name: 'ɵɵdefineDirective', moduleName: CORE };
+Identifiers.declareDirective = { name: 'ɵɵngDeclareDirective', moduleName: CORE };
+Identifiers.DirectiveDeclaration = {
     name: 'ɵɵDirectiveDeclaration',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
-Identifiers$1.InjectorDef = { name: 'ɵɵInjectorDef', moduleName: CORE$1 };
-Identifiers$1.InjectorDeclaration = { name: 'ɵɵInjectorDeclaration', moduleName: CORE$1 };
-Identifiers$1.defineInjector = { name: 'ɵɵdefineInjector', moduleName: CORE$1 };
-Identifiers$1.declareInjector = { name: 'ɵɵngDeclareInjector', moduleName: CORE$1 };
-Identifiers$1.NgModuleDeclaration = {
+Identifiers.InjectorDef = { name: 'ɵɵInjectorDef', moduleName: CORE };
+Identifiers.InjectorDeclaration = { name: 'ɵɵInjectorDeclaration', moduleName: CORE };
+Identifiers.defineInjector = { name: 'ɵɵdefineInjector', moduleName: CORE };
+Identifiers.declareInjector = { name: 'ɵɵngDeclareInjector', moduleName: CORE };
+Identifiers.NgModuleDeclaration = {
     name: 'ɵɵNgModuleDeclaration',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
-Identifiers$1.ModuleWithProviders = {
+Identifiers.ModuleWithProviders = {
     name: 'ModuleWithProviders',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
-Identifiers$1.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE$1 };
-Identifiers$1.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE$1 };
-Identifiers$1.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE$1 };
-Identifiers$1.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE$1 };
-Identifiers$1.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE$1 };
-Identifiers$1.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE$1 };
-Identifiers$1.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE$1 };
-Identifiers$1.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE$1 };
-Identifiers$1.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE$1 };
-Identifiers$1.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE$1 };
-Identifiers$1.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE$1 };
-Identifiers$1.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE$1 };
-Identifiers$1.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE$1 };
-Identifiers$1.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE$1 };
-Identifiers$1.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE$1 };
-Identifiers$1.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE$1 };
-Identifiers$1.listener = { name: 'ɵɵlistener', moduleName: CORE$1 };
-Identifiers$1.getInheritedFactory = {
+Identifiers.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE };
+Identifiers.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE };
+Identifiers.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE };
+Identifiers.registerNgModuleType = { name: 'ɵɵregisterNgModuleType', moduleName: CORE };
+Identifiers.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE };
+Identifiers.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE };
+Identifiers.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE };
+Identifiers.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE };
+Identifiers.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE };
+Identifiers.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE };
+Identifiers.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE };
+Identifiers.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE };
+Identifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE };
+Identifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE };
+Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE };
+Identifiers.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE };
+Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE };
+Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE };
+Identifiers.getInheritedFactory = {
     name: 'ɵɵgetInheritedFactory',
-    moduleName: CORE$1,
+    moduleName: CORE,
 };
 // sanitization-related functions
-Identifiers$1.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE$1 };
-Identifiers$1.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE$1 };
-Identifiers$1.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE$1 };
-Identifiers$1.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE$1 };
-Identifiers$1.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE$1 };
-Identifiers$1.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE$1 };
-Identifiers$1.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE$1 };
-Identifiers$1.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE$1 };
+Identifiers.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE };
+Identifiers.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE };
+Identifiers.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE };
+Identifiers.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE };
+Identifiers.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE };
+Identifiers.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE };
+Identifiers.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE };
+Identifiers.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE };
 
 /**
  * @license
@@ -3678,7 +3680,7 @@ function convertFromMaybeForwardRefExpression({ expression, forwardRef }) {
  * ```
  */
 function generateForwardRef(expr) {
-    return importExpr(Identifiers$1.forwardRef).callFn([fn([], [new ReturnStatement(expr)])]);
+    return importExpr(Identifiers.forwardRef).callFn([fn([], [new ReturnStatement(expr)])]);
 }
 
 var R3FactoryDelegateType;
@@ -3726,7 +3728,7 @@ function compileFactoryFunction(meta) {
         const r = variable('r');
         body.push(r.set(NULL_EXPR).toDeclStmt());
         const ctorStmt = ctorExpr !== null ? r.set(ctorExpr).toStmt() :
-            importExpr(Identifiers$1.invalidFactory).callFn([]).toStmt();
+            importExpr(Identifiers.invalidFactory).callFn([]).toStmt();
         body.push(ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
         return r;
     }
@@ -3749,11 +3751,11 @@ function compileFactoryFunction(meta) {
     }
     if (retExpr === null) {
         // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
-        body.push(importExpr(Identifiers$1.invalidFactory).callFn([]).toStmt());
+        body.push(importExpr(Identifiers.invalidFactory).callFn([]).toStmt());
     }
     else if (baseFactoryVar !== null) {
         // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
-        const getInheritedFactoryCall = importExpr(Identifiers$1.getInheritedFactory).callFn([meta.internalType]);
+        const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
         const baseFactory = new BinaryOperatorExpr(BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
         body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));
@@ -3778,7 +3780,7 @@ function compileFactoryFunction(meta) {
 }
 function createFactoryType(meta) {
     const ctorDepsType = meta.deps !== null && meta.deps !== 'invalid' ? createCtorDepsType(meta.deps) : NONE_TYPE;
-    return expressionType(importExpr(Identifiers$1.FactoryDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount), ctorDepsType]));
+    return expressionType(importExpr(Identifiers.FactoryDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount), ctorDepsType]));
 }
 function injectDependencies(deps, target) {
     return deps.map((dep, index) => compileInjectDependency(dep, target, index));
@@ -3786,7 +3788,7 @@ function injectDependencies(deps, target) {
 function compileInjectDependency(dep, target, index) {
     // Interpret the dependency according to its resolved type.
     if (dep.token === null) {
-        return importExpr(Identifiers$1.invalidFactoryDep).callFn([literal(index)]);
+        return importExpr(Identifiers.invalidFactoryDep).callFn([literal(index)]);
     }
     else if (dep.attributeNameType === null) {
         // Build up the injection flags according to the metadata.
@@ -3814,7 +3816,7 @@ function compileInjectDependency(dep, target, index) {
         //
         // The `dep.attributeTypeName` is only actually used (in `createCtorDepType()`) to generate
         // typings.
-        return importExpr(Identifiers$1.injectAttribute).callFn([dep.token]);
+        return importExpr(Identifiers.injectAttribute).callFn([dep.token]);
     }
 }
 function createCtorDepsType(deps) {
@@ -3866,11 +3868,11 @@ function getInjectFn(target) {
         case FactoryTarget$1.Component:
         case FactoryTarget$1.Directive:
         case FactoryTarget$1.Pipe:
-            return Identifiers$1.directiveInject;
+            return Identifiers.directiveInject;
         case FactoryTarget$1.NgModule:
         case FactoryTarget$1.Injectable:
         default:
-            return Identifiers$1.inject;
+            return Identifiers.inject;
     }
 }
 
@@ -4876,6 +4878,65 @@ const IMPLICIT_REFERENCE = '$implicit';
 const NON_BINDABLE_ATTR = 'ngNonBindable';
 /** Name for the variable keeping track of the context returned by `ɵɵrestoreView`. */
 const RESTORED_VIEW_CONTEXT_NAME = 'restoredCtx';
+/** Instructions that support chaining. */
+const CHAINABLE_INSTRUCTIONS = new Set([
+    Identifiers.element,
+    Identifiers.elementStart,
+    Identifiers.elementEnd,
+    Identifiers.elementContainer,
+    Identifiers.elementContainerStart,
+    Identifiers.elementContainerEnd,
+    Identifiers.i18nExp,
+    Identifiers.listener,
+    Identifiers.classProp,
+    Identifiers.syntheticHostListener,
+    Identifiers.hostProperty,
+    Identifiers.syntheticHostProperty,
+    Identifiers.property,
+    Identifiers.propertyInterpolate1,
+    Identifiers.propertyInterpolate2,
+    Identifiers.propertyInterpolate3,
+    Identifiers.propertyInterpolate4,
+    Identifiers.propertyInterpolate5,
+    Identifiers.propertyInterpolate6,
+    Identifiers.propertyInterpolate7,
+    Identifiers.propertyInterpolate8,
+    Identifiers.propertyInterpolateV,
+    Identifiers.attribute,
+    Identifiers.attributeInterpolate1,
+    Identifiers.attributeInterpolate2,
+    Identifiers.attributeInterpolate3,
+    Identifiers.attributeInterpolate4,
+    Identifiers.attributeInterpolate5,
+    Identifiers.attributeInterpolate6,
+    Identifiers.attributeInterpolate7,
+    Identifiers.attributeInterpolate8,
+    Identifiers.attributeInterpolateV,
+    Identifiers.styleProp,
+    Identifiers.stylePropInterpolate1,
+    Identifiers.stylePropInterpolate2,
+    Identifiers.stylePropInterpolate3,
+    Identifiers.stylePropInterpolate4,
+    Identifiers.stylePropInterpolate5,
+    Identifiers.stylePropInterpolate6,
+    Identifiers.stylePropInterpolate7,
+    Identifiers.stylePropInterpolate8,
+    Identifiers.stylePropInterpolateV,
+    Identifiers.textInterpolate,
+    Identifiers.textInterpolate1,
+    Identifiers.textInterpolate2,
+    Identifiers.textInterpolate3,
+    Identifiers.textInterpolate4,
+    Identifiers.textInterpolate5,
+    Identifiers.textInterpolate6,
+    Identifiers.textInterpolate7,
+    Identifiers.textInterpolate8,
+    Identifiers.textInterpolateV,
+]);
+/** Generates a call to a single instruction. */
+function invokeInstruction(span, reference, params) {
+    return importExpr(reference, null, span).callFn(params, span);
+}
 /**
  * Creates an allocator for a temporary variable.
  *
@@ -4966,7 +5027,7 @@ function getQueryPredicate(query, constantPool) {
             case 2 /* Unwrapped */:
                 return query.predicate.expression;
             case 1 /* Wrapped */:
-                return importExpr(Identifiers$1.resolveForwardRef).callFn([query.predicate.expression]);
+                return importExpr(Identifiers.resolveForwardRef).callFn([query.predicate.expression]);
         }
     }
 }
@@ -5017,20 +5078,6 @@ function getAttrsForDirectiveMatching(elOrTpl) {
     }
     return attributesMap;
 }
-/** Returns a call expression to a chained instruction, e.g. `property(params[0])(params[1])`. */
-function chainedInstruction(reference, calls, span) {
-    let expression = importExpr(reference, null, span);
-    if (calls.length > 0) {
-        for (let i = 0; i < calls.length; i++) {
-            expression = expression.callFn(calls[i], span);
-        }
-    }
-    else {
-        // Add a blank invocation, in case the `calls` array is empty.
-        expression = expression.callFn([], span);
-    }
-    return expression;
-}
 /**
  * Gets the number of arguments expected to be passed to a generated instruction in the case of
  * interpolation instructions.
@@ -5048,6 +5095,40 @@ function getInterpolationArgsLength(interpolation) {
         return expressions.length + strings.length;
     }
 }
+/**
+ * Generates the final instruction call statements based on the passed in configuration.
+ * Will try to chain instructions as much as possible, if chaining is supported.
+ */
+function getInstructionStatements(instructions) {
+    var _a;
+    const statements = [];
+    let pendingExpression = null;
+    let pendingExpressionType = null;
+    for (const current of instructions) {
+        const resolvedParams = (_a = (typeof current.paramsOrFn === 'function' ? current.paramsOrFn() : current.paramsOrFn)) !== null && _a !== void 0 ? _a : [];
+        const params = Array.isArray(resolvedParams) ? resolvedParams : [resolvedParams];
+        // If the current instruction is the same as the previous one
+        // and it can be chained, add another call to the chain.
+        if (pendingExpressionType === current.reference &&
+            CHAINABLE_INSTRUCTIONS.has(pendingExpressionType)) {
+            // We'll always have a pending expression when there's a pending expression type.
+            pendingExpression = pendingExpression.callFn(params, pendingExpression.sourceSpan);
+        }
+        else {
+            if (pendingExpression !== null) {
+                statements.push(pendingExpression.toStmt());
+            }
+            pendingExpression = invokeInstruction(current.span, current.reference, params);
+            pendingExpressionType = current.reference;
+        }
+    }
+    // Since the current instruction adds the previous one to the statements,
+    // we may be left with the final one at the end that is still pending.
+    if (pendingExpression !== null) {
+        statements.push(pendingExpression.toStmt());
+    }
+    return statements;
+}
 
 /**
  * @license
@@ -5111,7 +5192,7 @@ function compileInjectable(meta, resolveForwardRefs) {
     }
     else if (meta.useExisting !== undefined) {
         // useExisting is an `inject` call on the existing token.
-        result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: importExpr(Identifiers$1.inject).callFn([meta.useExisting.expression]) }));
+        result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: importExpr(Identifiers.inject).callFn([meta.useExisting.expression]) }));
     }
     else {
         result = {
@@ -5127,7 +5208,7 @@ function compileInjectable(meta, resolveForwardRefs) {
     if (meta.providedIn.expression.value !== null) {
         injectableProps.set('providedIn', convertFromMaybeForwardRefExpression(meta.providedIn));
     }
-    const expression = importExpr(Identifiers$1.ɵɵdefineInjectable)
+    const expression = importExpr(Identifiers.ɵɵdefineInjectable)
         .callFn([injectableProps.toLiteralMap()], undefined, true);
     return {
         expression,
@@ -5136,7 +5217,7 @@ function compileInjectable(meta, resolveForwardRefs) {
     };
 }
 function createInjectableType(meta) {
-    return new ExpressionType(importExpr(Identifiers$1.InjectableDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount)]));
+    return new ExpressionType(importExpr(Identifiers.InjectableDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount)]));
 }
 function delegateToFactory(type, internalType, unwrapForwardRefs) {
     if (type.node === internalType.node) {
@@ -5159,7 +5240,7 @@ function delegateToFactory(type, internalType, unwrapForwardRefs) {
     // ```
     // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); }
     // ```
-    const unwrappedType = importExpr(Identifiers$1.resolveForwardRef).callFn([internalType]);
+    const unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([internalType]);
     return createFactoryFunction(unwrappedType);
 }
 function createFactoryFunction(type) {
@@ -5337,7 +5418,7 @@ class ParseLocation {
             const ch = source.charCodeAt(offset);
             if (ch == $LF) {
                 line--;
-                const priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF));
+                const priorLine = source.substring(0, offset - 1).lastIndexOf(String.fromCharCode($LF));
                 col = priorLine > 0 ? offset - priorLine : offset;
             }
             else {
@@ -5848,12 +5929,12 @@ function compileInjector(meta) {
     if (meta.imports.length > 0) {
         definitionMap.set('imports', literalArr(meta.imports));
     }
-    const expression = importExpr(Identifiers$1.defineInjector).callFn([definitionMap.toLiteralMap()], undefined, true);
+    const expression = importExpr(Identifiers.defineInjector).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createInjectorType(meta);
     return { expression, type, statements: [] };
 }
 function createInjectorType(meta) {
-    return new ExpressionType(importExpr(Identifiers$1.InjectorDeclaration, [new ExpressionType(meta.type.type)]));
+    return new ExpressionType(importExpr(Identifiers.InjectorDeclaration, [new ExpressionType(meta.type.type)]));
 }
 
 /**
@@ -5892,20 +5973,49 @@ class R3JitReflector {
  * 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
  */
+/**
+ * How the selector scope of an NgModule (its declarations, imports, and exports) should be emitted
+ * as a part of the NgModule definition.
+ */
+var R3SelectorScopeMode;
+(function (R3SelectorScopeMode) {
+    /**
+     * Emit the declarations inline into the module definition.
+     *
+     * This option is useful in certain contexts where it's known that JIT support is required. The
+     * tradeoff here is that this emit style prevents directives and pipes from being tree-shaken if
+     * they are unused, but the NgModule is used.
+     */
+    R3SelectorScopeMode[R3SelectorScopeMode["Inline"] = 0] = "Inline";
+    /**
+     * Emit the declarations using a side effectful function call, `ɵɵsetNgModuleScope`, that is
+     * guarded with the `ngJitMode` flag.
+     *
+     * This form of emit supports JIT and can be optimized away if the `ngJitMode` flag is set to
+     * false, which allows unused directives and pipes to be tree-shaken.
+     */
+    R3SelectorScopeMode[R3SelectorScopeMode["SideEffect"] = 1] = "SideEffect";
+    /**
+     * Don't generate selector scopes at all.
+     *
+     * This is useful for contexts where JIT support is known to be unnecessary.
+     */
+    R3SelectorScopeMode[R3SelectorScopeMode["Omit"] = 2] = "Omit";
+})(R3SelectorScopeMode || (R3SelectorScopeMode = {}));
 /**
  * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`.
  */
 function compileNgModule(meta) {
-    const { internalType, bootstrap, declarations, imports, exports, schemas, containsForwardDecls, emitInline, id } = meta;
+    const { adjacentType, internalType, bootstrap, declarations, imports, exports, schemas, containsForwardDecls, selectorScopeMode, id } = meta;
     const statements = [];
     const definitionMap = new DefinitionMap();
     definitionMap.set('type', internalType);
     if (bootstrap.length > 0) {
         definitionMap.set('bootstrap', refsToArray(bootstrap, containsForwardDecls));
     }
-    // If requested to emit scope information inline, pass the `declarations`, `imports` and `exports`
-    // to the `ɵɵdefineNgModule()` call. The JIT compilation uses this.
-    if (emitInline) {
+    if (selectorScopeMode === R3SelectorScopeMode.Inline) {
+        // If requested to emit scope information inline, pass the `declarations`, `imports` and
+        // `exports` to the `ɵɵdefineNgModule()` call directly.
         if (declarations.length > 0) {
             definitionMap.set('declarations', refsToArray(declarations, containsForwardDecls));
         }
@@ -5916,21 +6026,29 @@ function compileNgModule(meta) {
             definitionMap.set('exports', refsToArray(exports, containsForwardDecls));
         }
     }
-    // If not emitting inline, the scope information is not passed into `ɵɵdefineNgModule` as it would
-    // prevent tree-shaking of the declarations, imports and exports references.
-    else {
+    else if (selectorScopeMode === R3SelectorScopeMode.SideEffect) {
+        // In this mode, scope information is not passed into `ɵɵdefineNgModule` as it
+        // would prevent tree-shaking of the declarations, imports and exports references. Instead, it's
+        // patched onto the NgModule definition with a `ɵɵsetNgModuleScope` call that's guarded by the
+        // `ngJitMode` flag.
         const setNgModuleScopeCall = generateSetNgModuleScopeCall(meta);
         if (setNgModuleScopeCall !== null) {
             statements.push(setNgModuleScopeCall);
         }
     }
+    else {
+        // Selector scope emit was not requested, so skip it.
+    }
     if (schemas !== null && schemas.length > 0) {
         definitionMap.set('schemas', literalArr(schemas.map(ref => ref.value)));
     }
     if (id !== null) {
         definitionMap.set('id', id);
+        // Generate a side-effectful call to register this NgModule by its id, as per the semantics of
+        // NgModule ids.
+        statements.push(importExpr(Identifiers.registerNgModuleType).callFn([adjacentType, id]).toStmt());
     }
-    const expression = importExpr(Identifiers$1.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true);
+    const expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createNgModuleType(meta);
     return { expression, type, statements };
 }
@@ -5959,10 +6077,10 @@ function compileNgModuleDeclarationExpression(meta) {
     if (meta.id !== undefined) {
         definitionMap.set('id', new WrappedNodeExpr(meta.id));
     }
-    return importExpr(Identifiers$1.defineNgModule).callFn([definitionMap.toLiteralMap()]);
+    return importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()]);
 }
 function createNgModuleType({ type: moduleType, declarations, imports, exports }) {
-    return new ExpressionType(importExpr(Identifiers$1.NgModuleDeclaration, [
+    return new ExpressionType(importExpr(Identifiers.NgModuleDeclaration, [
         new ExpressionType(moduleType.type), tupleTypeOf(declarations), tupleTypeOf(imports),
         tupleTypeOf(exports)
     ]));
@@ -5990,7 +6108,7 @@ function generateSetNgModuleScopeCall(meta) {
     }
     // setNgModuleScope(...)
     const fnCall = new InvokeFunctionExpr(
-    /* fn */ importExpr(Identifiers$1.setNgModuleScope), 
+    /* fn */ importExpr(Identifiers.setNgModuleScope), 
     /* args */ [moduleType, scopeMap.toLiteralMap()]);
     // (ngJitMode guard) && setNgModuleScope(...)
     const guardedCall = jitOnlyGuardedExpression(fnCall);
@@ -6024,12 +6142,15 @@ function compilePipeFromMetadata(metadata) {
     definitionMapValues.push({ key: 'type', value: metadata.type.value, quoted: false });
     // e.g. `pure: true`
     definitionMapValues.push({ key: 'pure', value: literal(metadata.pure), quoted: false });
-    const expression = importExpr(Identifiers$1.definePipe).callFn([literalMap(definitionMapValues)], undefined, true);
+    if (metadata.isStandalone) {
+        definitionMapValues.push({ key: 'standalone', value: literal(true), quoted: false });
+    }
+    const expression = importExpr(Identifiers.definePipe).callFn([literalMap(definitionMapValues)], undefined, true);
     const type = createPipeType(metadata);
     return { expression, type, statements: [] };
 }
 function createPipeType(metadata) {
-    return new ExpressionType(importExpr(Identifiers$1.PipeDeclaration, [
+    return new ExpressionType(importExpr(Identifiers.PipeDeclaration, [
         typeWithParameters(metadata.type.type, metadata.typeArgumentCount),
         new ExpressionType(new LiteralExpr(metadata.pipeName)),
     ]));
@@ -6078,33 +6199,6 @@ class ASTWithName extends AST {
         this.nameSpan = nameSpan;
     }
 }
-/**
- * Represents a quoted expression of the form:
- *
- * quote = prefix `:` uninterpretedExpression
- * prefix = identifier
- * uninterpretedExpression = arbitrary string
- *
- * A quoted expression is meant to be pre-processed by an AST transformer that
- * converts it into another AST that no longer contains quoted expressions.
- * It is meant to allow third-party developers to extend Angular template
- * expression language. The `uninterpretedExpression` part of the quote is
- * therefore not interpreted by the Angular's own expression parser.
- */
-class Quote extends AST {
-    constructor(span, sourceSpan, prefix, uninterpretedExpression, location) {
-        super(span, sourceSpan);
-        this.prefix = prefix;
-        this.uninterpretedExpression = uninterpretedExpression;
-        this.location = location;
-    }
-    visit(visitor, context = null) {
-        return visitor.visitQuote(this, context);
-    }
-    toString() {
-        return 'Quote';
-    }
-}
 class EmptyExpr extends AST {
     visit(visitor, context = null) {
         // do nothing
@@ -6485,7 +6579,6 @@ class RecursiveAstVisitor {
         this.visit(ast.receiver, context);
         this.visitAll(ast.args, context);
     }
-    visitQuote(ast, context) { }
     // This is not part of the AstVisitor interface, just a helper method
     visitAll(asts, context) {
         for (const ast of asts) {
@@ -6568,9 +6661,6 @@ class AstTransformer {
     visitChain(ast, context) {
         return new Chain(ast.span, ast.sourceSpan, this.visitAll(ast.expressions));
     }
-    visitQuote(ast, context) {
-        return new Quote(ast.span, ast.sourceSpan, ast.prefix, ast.uninterpretedExpression, ast.location);
-    }
     visitSafeKeyedRead(ast, context) {
         return new SafeKeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this));
     }
@@ -6733,9 +6823,6 @@ class AstMemoryEfficientTransformer {
         }
         return ast;
     }
-    visitQuote(ast, context) {
-        return ast;
-    }
     visitSafeKeyedRead(ast, context) {
         const obj = ast.receiver.visit(this);
         const key = ast.key.visit(this);
@@ -6802,98 +6889,6 @@ class BoundElementProperty {
     }
 }
 
-/**
- * @license
- * Copyright Google LLC 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
- */
-const CORE = '@angular/core';
-class Identifiers {
-}
-Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS = {
-    name: 'ANALYZE_FOR_ENTRY_COMPONENTS',
-    moduleName: CORE,
-};
-Identifiers.ElementRef = { name: 'ElementRef', moduleName: CORE };
-Identifiers.NgModuleRef = { name: 'NgModuleRef', moduleName: CORE };
-Identifiers.ViewContainerRef = { name: 'ViewContainerRef', moduleName: CORE };
-Identifiers.ChangeDetectorRef = {
-    name: 'ChangeDetectorRef',
-    moduleName: CORE,
-};
-Identifiers.QueryList = { name: 'QueryList', moduleName: CORE };
-Identifiers.TemplateRef = { name: 'TemplateRef', moduleName: CORE };
-Identifiers.Renderer2 = { name: 'Renderer2', moduleName: CORE };
-Identifiers.CodegenComponentFactoryResolver = {
-    name: 'ɵCodegenComponentFactoryResolver',
-    moduleName: CORE,
-};
-Identifiers.ComponentFactoryResolver = {
-    name: 'ComponentFactoryResolver',
-    moduleName: CORE,
-};
-Identifiers.ComponentFactory = { name: 'ComponentFactory', moduleName: CORE };
-Identifiers.ComponentRef = { name: 'ComponentRef', moduleName: CORE };
-Identifiers.NgModuleFactory = { name: 'NgModuleFactory', moduleName: CORE };
-Identifiers.createModuleFactory = {
-    name: 'ɵcmf',
-    moduleName: CORE,
-};
-Identifiers.moduleDef = {
-    name: 'ɵmod',
-    moduleName: CORE,
-};
-Identifiers.moduleProviderDef = {
-    name: 'ɵmpd',
-    moduleName: CORE,
-};
-Identifiers.RegisterModuleFactoryFn = {
-    name: 'ɵregisterModuleFactory',
-    moduleName: CORE,
-};
-Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE };
-Identifiers.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE };
-Identifiers.INJECTOR = { name: 'INJECTOR', moduleName: CORE };
-Identifiers.Injector = { name: 'Injector', moduleName: CORE };
-Identifiers.ViewEncapsulation = {
-    name: 'ViewEncapsulation',
-    moduleName: CORE,
-};
-Identifiers.ChangeDetectionStrategy = {
-    name: 'ChangeDetectionStrategy',
-    moduleName: CORE,
-};
-Identifiers.SecurityContext = {
-    name: 'SecurityContext',
-    moduleName: CORE,
-};
-Identifiers.LOCALE_ID = { name: 'LOCALE_ID', moduleName: CORE };
-Identifiers.TRANSLATIONS_FORMAT = {
-    name: 'TRANSLATIONS_FORMAT',
-    moduleName: CORE,
-};
-Identifiers.inlineInterpolate = {
-    name: 'ɵinlineInterpolate',
-    moduleName: CORE,
-};
-Identifiers.interpolate = { name: 'ɵinterpolate', moduleName: CORE };
-Identifiers.EMPTY_ARRAY = { name: 'ɵEMPTY_ARRAY', moduleName: CORE };
-Identifiers.EMPTY_MAP = { name: 'ɵEMPTY_MAP', moduleName: CORE };
-Identifiers.Renderer = { name: 'Renderer', moduleName: CORE };
-// type only
-Identifiers.RendererType2 = {
-    name: 'RendererType2',
-    moduleName: CORE,
-};
-// type only
-Identifiers.ViewDefinition = {
-    name: 'ɵViewDefinition',
-    moduleName: CORE,
-};
-Identifiers.createComponentFactory = { name: 'ɵccf', moduleName: CORE };
-
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -6908,7 +6903,7 @@ EventHandlerVars.event = variable('$event');
  * Converts the given expression AST into an executable output AST, assuming the expression is
  * used in an action binding (e.g. an event handler).
  */
-function convertActionBinding(localResolver, implicitReceiver, action, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses, globals) {
+function convertActionBinding(localResolver, implicitReceiver, action, bindingId, baseSourceSpan, implicitReceiverAccesses, globals) {
     if (!localResolver) {
         localResolver = new DefaultLocalResolver(globals);
     }
@@ -6932,7 +6927,7 @@ function convertActionBinding(localResolver, implicitReceiver, action, bindingId
             throw new Error(`Illegal State: Actions are not allowed to contain pipes. Pipe: ${name}`);
         }
     }, action);
-    const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses);
+    const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, /* supportsInterpolation */ false, baseSourceSpan, implicitReceiverAccesses);
     const actionStmts = [];
     flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);
     prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
@@ -6963,11 +6958,11 @@ class ConvertPropertyBindingResult {
  * is used in property binding. The expression has to be preprocessed via
  * `convertPropertyBindingBuiltins`.
  */
-function convertPropertyBinding(localResolver, implicitReceiver, expressionWithoutBuiltins, bindingId, interpolationFunction) {
+function convertPropertyBinding(localResolver, implicitReceiver, expressionWithoutBuiltins, bindingId) {
     if (!localResolver) {
         localResolver = new DefaultLocalResolver();
     }
-    const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction);
+    const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, /* supportsInterpolation */ false);
     const outputExpr = expressionWithoutBuiltins.visit(visitor, _Mode.Expression);
     const stmts = getStatementsFromVisitor(visitor, bindingId);
     if (visitor.usesImplicitReceiver) {
@@ -6992,28 +6987,13 @@ function convertPropertyBinding(localResolver, implicitReceiver, expressionWitho
  * `o.importExpr(R3.propertyInterpolate).callFn(result)`
  */
 function convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) {
-    const visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, undefined);
-    const outputExpr = expressionWithArgumentsToExtract.visit(visitor, _Mode.Expression);
+    const visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, /* supportsInterpolation */ true);
+    const outputExpr = visitor.visitInterpolation(expressionWithArgumentsToExtract, _Mode.Expression);
     if (visitor.usesImplicitReceiver) {
         localResolver.notifyImplicitReceiverUse();
     }
     const stmts = getStatementsFromVisitor(visitor, bindingId);
-    // Removing the first argument, because it was a length for ViewEngine, not Ivy.
-    let args = outputExpr.args.slice(1);
-    if (expressionWithArgumentsToExtract instanceof Interpolation) {
-        // If we're dealing with an interpolation of 1 value with an empty prefix and suffix, reduce the
-        // args returned to just the value, because we're going to pass it to a special instruction.
-        const strings = expressionWithArgumentsToExtract.strings;
-        if (args.length === 3 && strings[0] === '' && strings[1] === '') {
-            // Single argument interpolate instructions.
-            args = [args[1]];
-        }
-        else if (args.length >= 19) {
-            // 19 or more arguments must be passed to the `interpolateV`-style instructions, which accept
-            // an array of arguments
-            args = [literalArr(args)];
-        }
-    }
+    const args = outputExpr.args;
     return { stmts, args };
 }
 function getStatementsFromVisitor(visitor, bindingId) {
@@ -7080,11 +7060,11 @@ class _BuiltinAstConverter extends AstTransformer {
     }
 }
 class _AstToIrVisitor {
-    constructor(_localResolver, _implicitReceiver, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses) {
+    constructor(_localResolver, _implicitReceiver, bindingId, supportsInterpolation, baseSourceSpan, implicitReceiverAccesses) {
         this._localResolver = _localResolver;
         this._implicitReceiver = _implicitReceiver;
         this.bindingId = bindingId;
-        this.interpolationFunction = interpolationFunction;
+        this.supportsInterpolation = supportsInterpolation;
         this.baseSourceSpan = baseSourceSpan;
         this.implicitReceiverAccesses = implicitReceiverAccesses;
         this._nodeMap = new Map();
@@ -7182,21 +7162,29 @@ class _AstToIrVisitor {
         return this.visitImplicitReceiver(ast, mode);
     }
     visitInterpolation(ast, mode) {
+        if (!this.supportsInterpolation) {
+            throw new Error('Unexpected interpolation');
+        }
         ensureExpressionMode(mode, ast);
-        const args = [literal(ast.expressions.length)];
+        let args = [];
         for (let i = 0; i < ast.strings.length - 1; i++) {
             args.push(literal(ast.strings[i]));
             args.push(this._visit(ast.expressions[i], _Mode.Expression));
         }
         args.push(literal(ast.strings[ast.strings.length - 1]));
-        if (this.interpolationFunction) {
-            return this.interpolationFunction(args);
+        // If we're dealing with an interpolation of 1 value with an empty prefix and suffix, reduce the
+        // args returned to just the value, because we're going to pass it to a special instruction.
+        const strings = ast.strings;
+        if (strings.length === 2 && strings[0] === '' && strings[1] === '') {
+            // Single argument interpolate instructions.
+            args = [args[1]];
         }
-        return ast.expressions.length <= 9 ?
-            importExpr(Identifiers.inlineInterpolate).callFn(args) :
-            importExpr(Identifiers.interpolate).callFn([
-                args[0], literalArr(args.slice(1), undefined, this.convertSourceSpan(ast.span))
-            ]);
+        else if (ast.expressions.length >= 9) {
+            // 9 or more arguments must be passed to the `interpolateV`-style instructions, which accept
+            // an array of arguments
+            args = [literalArr(args)];
+        }
+        return new InterpolationExpression(args);
     }
     visitKeyedRead(ast, mode) {
         const leftMostSafe = this.leftMostSafeNode(ast);
@@ -7308,10 +7296,6 @@ class _AstToIrVisitor {
     visitAll(asts, mode) {
         return asts.map(ast => this._visit(ast, mode));
     }
-    visitQuote(ast, mode) {
-        throw new Error(`Quotes are not supported for evaluation!
-        Statement: ${ast.uninterpretedExpression} located at ${ast.location}`);
-    }
     visitCall(ast, mode) {
         const leftMostSafe = this.leftMostSafeNode(ast);
         if (leftMostSafe) {
@@ -7497,9 +7481,6 @@ class _AstToIrVisitor {
             visitPropertyWrite(ast) {
                 return null;
             },
-            visitQuote(ast) {
-                return null;
-            },
             visitSafePropertyRead(ast) {
                 return visit(this, ast.receiver) || ast;
             },
@@ -7576,9 +7557,6 @@ class _AstToIrVisitor {
             visitPropertyWrite(ast) {
                 return false;
             },
-            visitQuote(ast) {
-                return false;
-            },
             visitSafePropertyRead(ast) {
                 return false;
             },
@@ -7635,6 +7613,18 @@ function flattenStatements(arg, output) {
         output.push(arg);
     }
 }
+function unsupported() {
+    throw new Error('Unsupported operation');
+}
+class InterpolationExpression extends Expression {
+    constructor(args) {
+        super(null, null);
+        this.args = args;
+        this.isConstant = unsupported;
+        this.isEquivalent = unsupported;
+        this.visitExpression = unsupported;
+    }
+}
 class DefaultLocalResolver {
     constructor(globals) {
         this.globals = globals;
@@ -8009,7 +7999,7 @@ class ShadowCss {
                     this._scopeSelector(rule.selector, scopeSelector, hostSelector, this.strictStyling);
             }
             else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
-                rule.selector.startsWith('@document')) {
+                rule.selector.startsWith('@document') || rule.selector.startsWith('@layer')) {
                 content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
             }
             else if (rule.selector.startsWith('@font-face') || rule.selector.startsWith('@page')) {
@@ -8472,7 +8462,7 @@ function parse(value) {
         }
     }
     if (currentProp && valueStart) {
-        const styleVal = value.substr(valueStart).trim();
+        const styleVal = value.slice(valueStart).trim();
         styles.push(currentProp, valueHasQuotes ? stripUnnecessaryQuotes(styleVal) : styleVal);
     }
     return styles;
@@ -8650,7 +8640,7 @@ class StylingBuilder {
         const isClass = !isStyle && (name === 'class' || prefix === 'class.' || prefix === 'class!');
         if (isStyle || isClass) {
             const isMapBased = name.charAt(5) !== '.'; // style.prop or class.prop makes this a no
-            const property = name.substr(isMapBased ? 5 : 6); // the dot explains why there's a +1
+            const property = name.slice(isMapBased ? 5 : 6); // the dot explains why there's a +1
             if (isStyle) {
                 binding = this.registerStyleInput(property, isMapBased, expression, sourceSpan);
             }
@@ -8803,7 +8793,7 @@ class StylingBuilder {
                 getStyleMapInterpolationExpression(mapValue);
         }
         else {
-            reference = isClassBased ? Identifiers$1.classMap : Identifiers$1.styleMap;
+            reference = isClassBased ? Identifiers.classMap : Identifiers.styleMap;
         }
         return {
             reference,
@@ -8877,13 +8867,13 @@ class StylingBuilder {
     }
     _buildClassInputs(valueConverter) {
         if (this._singleClassInputs) {
-            return this._buildSingleInputs(Identifiers$1.classProp, this._singleClassInputs, valueConverter, null, true);
+            return this._buildSingleInputs(Identifiers.classProp, this._singleClassInputs, valueConverter, null, true);
         }
         return [];
     }
     _buildStyleInputs(valueConverter) {
         if (this._singleStyleInputs) {
-            return this._buildSingleInputs(Identifiers$1.styleProp, this._singleStyleInputs, valueConverter, getStylePropInterpolationExpression, false);
+            return this._buildSingleInputs(Identifiers.styleProp, this._singleStyleInputs, valueConverter, getStylePropInterpolationExpression, false);
         }
         return [];
     }
@@ -8924,7 +8914,7 @@ function parseProperty(name) {
     let property = name;
     const unitIndex = name.lastIndexOf('.');
     if (unitIndex > 0) {
-        suffix = name.substr(unitIndex + 1);
+        suffix = name.slice(unitIndex + 1);
         property = name.substring(0, unitIndex);
     }
     return { property, suffix, hasOverrideFlag };
@@ -8936,25 +8926,25 @@ function parseProperty(name) {
 function getClassMapInterpolationExpression(interpolation) {
     switch (getInterpolationArgsLength(interpolation)) {
         case 1:
-            return Identifiers$1.classMap;
+            return Identifiers.classMap;
         case 3:
-            return Identifiers$1.classMapInterpolate1;
+            return Identifiers.classMapInterpolate1;
         case 5:
-            return Identifiers$1.classMapInterpolate2;
+            return Identifiers.classMapInterpolate2;
         case 7:
-            return Identifiers$1.classMapInterpolate3;
+            return Identifiers.classMapInterpolate3;
         case 9:
-            return Identifiers$1.classMapInterpolate4;
+            return Identifiers.classMapInterpolate4;
         case 11:
-            return Identifiers$1.classMapInterpolate5;
+            return Identifiers.classMapInterpolate5;
         case 13:
-            return Identifiers$1.classMapInterpolate6;
+            return Identifiers.classMapInterpolate6;
         case 15:
-            return Identifiers$1.classMapInterpolate7;
+            return Identifiers.classMapInterpolate7;
         case 17:
-            return Identifiers$1.classMapInterpolate8;
+            return Identifiers.classMapInterpolate8;
         default:
-            return Identifiers$1.classMapInterpolateV;
+            return Identifiers.classMapInterpolateV;
     }
 }
 /**
@@ -8964,25 +8954,25 @@ function getClassMapInterpolationExpression(interpolation) {
 function getStyleMapInterpolationExpression(interpolation) {
     switch (getInterpolationArgsLength(interpolation)) {
         case 1:
-            return Identifiers$1.styleMap;
+            return Identifiers.styleMap;
         case 3:
-            return Identifiers$1.styleMapInterpolate1;
+            return Identifiers.styleMapInterpolate1;
         case 5:
-            return Identifiers$1.styleMapInterpolate2;
+            return Identifiers.styleMapInterpolate2;
         case 7:
-            return Identifiers$1.styleMapInterpolate3;
+            return Identifiers.styleMapInterpolate3;
         case 9:
-            return Identifiers$1.styleMapInterpolate4;
+            return Identifiers.styleMapInterpolate4;
         case 11:
-            return Identifiers$1.styleMapInterpolate5;
+            return Identifiers.styleMapInterpolate5;
         case 13:
-            return Identifiers$1.styleMapInterpolate6;
+            return Identifiers.styleMapInterpolate6;
         case 15:
-            return Identifiers$1.styleMapInterpolate7;
+            return Identifiers.styleMapInterpolate7;
         case 17:
-            return Identifiers$1.styleMapInterpolate8;
+            return Identifiers.styleMapInterpolate8;
         default:
-            return Identifiers$1.styleMapInterpolateV;
+            return Identifiers.styleMapInterpolateV;
     }
 }
 /**
@@ -8992,25 +8982,25 @@ function getStyleMapInterpolationExpression(interpolation) {
 function getStylePropInterpolationExpression(interpolation) {
     switch (getInterpolationArgsLength(interpolation)) {
         case 1:
-            return Identifiers$1.styleProp;
+            return Identifiers.styleProp;
         case 3:
-            return Identifiers$1.stylePropInterpolate1;
+            return Identifiers.stylePropInterpolate1;
         case 5:
-            return Identifiers$1.stylePropInterpolate2;
+            return Identifiers.stylePropInterpolate2;
         case 7:
-            return Identifiers$1.stylePropInterpolate3;
+            return Identifiers.stylePropInterpolate3;
         case 9:
-            return Identifiers$1.stylePropInterpolate4;
+            return Identifiers.stylePropInterpolate4;
         case 11:
-            return Identifiers$1.stylePropInterpolate5;
+            return Identifiers.stylePropInterpolate5;
         case 13:
-            return Identifiers$1.stylePropInterpolate6;
+            return Identifiers.stylePropInterpolate6;
         case 15:
-            return Identifiers$1.stylePropInterpolate7;
+            return Identifiers.stylePropInterpolate7;
         case 17:
-            return Identifiers$1.stylePropInterpolate8;
+            return Identifiers.stylePropInterpolate8;
         default:
-            return Identifiers$1.stylePropInterpolateV;
+            return Identifiers.stylePropInterpolateV;
     }
 }
 /**
@@ -9471,11 +9461,15 @@ class Parser$1 {
         this._lexer = _lexer;
         this.errors = [];
     }
-    parseAction(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseAction(input, isAssignmentEvent, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         this._checkNoInterpolation(input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        const ast = new _ParseAST(input, location, absoluteOffset, tokens, true, this.errors, 0).parseChain();
+        let flags = 1 /* Action */;
+        if (isAssignmentEvent) {
+            flags |= 2 /* AssignmentEvent */;
+        }
+        const ast = new _ParseAST(input, location, absoluteOffset, tokens, flags, this.errors, 0).parseChain();
         return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);
     }
     parseBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
@@ -9499,31 +9493,12 @@ class Parser$1 {
         this.errors.push(new ParserError(message, input, errLocation, ctxLocation));
     }
     _parseBindingAst(input, location, absoluteOffset, interpolationConfig) {
-        // Quotes expressions use 3rd-party expression language. We don't want to use
-        // our lexer or parser for that, so we check for that ahead of time.
-        const quote = this._parseQuote(input, location, absoluteOffset);
-        if (quote != null) {
-            return quote;
-        }
         this._checkNoInterpolation(input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        return new _ParseAST(input, location, absoluteOffset, tokens, false, this.errors, 0)
+        return new _ParseAST(input, location, absoluteOffset, tokens, 0 /* None */, this.errors, 0)
             .parseChain();
     }
-    _parseQuote(input, location, absoluteOffset) {
-        if (input == null)
-            return null;
-        const prefixSeparatorIndex = input.indexOf(':');
-        if (prefixSeparatorIndex == -1)
-            return null;
-        const prefix = input.substring(0, prefixSeparatorIndex).trim();
-        if (!isIdentifier(prefix))
-            return null;
-        const uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);
-        const span = new ParseSpan(0, input.length);
-        return new Quote(span, span.toAbsolute(absoluteOffset), prefix, uninterpretedExpression, location);
-    }
     /**
      * Parse microsyntax template expression and return a list of bindings or
      * parsing errors in case the given expression is invalid.
@@ -9552,14 +9527,14 @@ class Parser$1 {
      */
     parseTemplateBindings(templateKey, templateValue, templateUrl, absoluteKeyOffset, absoluteValueOffset) {
         const tokens = this._lexer.tokenize(templateValue);
-        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, false /* parseAction */, this.errors, 0 /* relative offset */);
+        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, 0 /* None */, this.errors, 0 /* relative offset */);
         return parser.parseTemplateBindings({
             source: templateKey,
             span: new AbsoluteSourceSpan(absoluteKeyOffset, absoluteKeyOffset + templateKey.length),
         });
     }
-    parseInterpolation(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-        const { strings, expressions, offsets } = this.splitInterpolation(input, location, interpolationConfig);
+    parseInterpolation(input, location, absoluteOffset, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        const { strings, expressions, offsets } = this.splitInterpolation(input, location, interpolatedTokens, interpolationConfig);
         if (expressions.length === 0)
             return null;
         const expressionNodes = [];
@@ -9567,7 +9542,7 @@ class Parser$1 {
             const expressionText = expressions[i].text;
             const sourceToLex = this._stripComments(expressionText);
             const tokens = this._lexer.tokenize(sourceToLex);
-            const ast = new _ParseAST(input, location, absoluteOffset, tokens, false, this.errors, offsets[i])
+            const ast = new _ParseAST(input, location, absoluteOffset, tokens, 0 /* None */, this.errors, offsets[i])
                 .parseChain();
             expressionNodes.push(ast);
         }
@@ -9581,8 +9556,7 @@ class Parser$1 {
     parseInterpolationExpression(expression, location, absoluteOffset) {
         const sourceToLex = this._stripComments(expression);
         const tokens = this._lexer.tokenize(sourceToLex);
-        const ast = new _ParseAST(expression, location, absoluteOffset, tokens, 
-        /* parseAction */ false, this.errors, 0)
+        const ast = new _ParseAST(expression, location, absoluteOffset, tokens, 0 /* None */, this.errors, 0)
             .parseChain();
         const strings = ['', '']; // The prefix and suffix strings are both empty
         return this.createInterpolationAst(strings, [ast], expression, location, absoluteOffset);
@@ -9599,10 +9573,12 @@ class Parser$1 {
      * `SplitInterpolation` with splits that look like
      *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
      */
-    splitInterpolation(input, location, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    splitInterpolation(input, location, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+        var _a;
         const strings = [];
         const expressions = [];
         const offsets = [];
+        const inputToTemplateIndexMap = interpolatedTokens ? getIndexMapForOriginalTemplate(interpolatedTokens) : null;
         let i = 0;
         let atInterpolation = false;
         let extendLastString = false;
@@ -9637,7 +9613,9 @@ class Parser$1 {
                     this._reportError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, location);
                 }
                 expressions.push({ text, start: fullStart, end: fullEnd });
-                offsets.push(exprStart);
+                const startInOriginalTemplate = (_a = inputToTemplateIndexMap === null || inputToTemplateIndexMap === void 0 ? void 0 : inputToTemplateIndexMap.get(fullStart)) !== null && _a !== void 0 ? _a : fullStart;
+                const offset = startInOriginalTemplate + interpStart.length;
+                offsets.push(offset);
                 i = fullEnd;
                 atInterpolation = false;
             }
@@ -9753,12 +9731,12 @@ var ParseContextFlags;
     ParseContextFlags[ParseContextFlags["Writable"] = 1] = "Writable";
 })(ParseContextFlags || (ParseContextFlags = {}));
 class _ParseAST {
-    constructor(input, location, absoluteOffset, tokens, parseAction, errors, offset) {
+    constructor(input, location, absoluteOffset, tokens, parseFlags, errors, offset) {
         this.input = input;
         this.location = location;
         this.absoluteOffset = absoluteOffset;
         this.tokens = tokens;
-        this.parseAction = parseAction;
+        this.parseFlags = parseFlags;
         this.errors = errors;
         this.offset = offset;
         this.rparensExpected = 0;
@@ -9935,7 +9913,7 @@ class _ParseAST {
             const expr = this.parsePipe();
             exprs.push(expr);
             if (this.consumeOptionalCharacter($SEMICOLON)) {
-                if (!this.parseAction) {
+                if (!(this.parseFlags & 1 /* Action */)) {
                     this.error('Binding expression cannot contain chained expression');
                 }
                 while (this.consumeOptionalCharacter($SEMICOLON)) {
@@ -9959,7 +9937,7 @@ class _ParseAST {
         const start = this.inputIndex;
         let result = this.parseExpression();
         if (this.consumeOptionalOperator('|')) {
-            if (this.parseAction) {
+            if (this.parseFlags & 1 /* Action */) {
                 this.error('Cannot have a pipe in an action expression');
             }
             do {
@@ -10302,7 +10280,7 @@ class _ParseAST {
         const nameSpan = this.sourceSpan(nameStart);
         let receiver;
         if (isSafe) {
-            if (this.consumeOptionalOperator('=')) {
+            if (this.consumeOptionalAssignment()) {
                 this.error('The \'?.\' operator cannot be used in the assignment');
                 receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
             }
@@ -10311,8 +10289,8 @@ class _ParseAST {
             }
         }
         else {
-            if (this.consumeOptionalOperator('=')) {
-                if (!this.parseAction) {
+            if (this.consumeOptionalAssignment()) {
+                if (!(this.parseFlags & 1 /* Action */)) {
                     this.error('Bindings cannot contain assignments');
                     return new EmptyExpr(this.span(start), this.sourceSpan(start));
                 }
@@ -10338,6 +10316,22 @@ class _ParseAST {
         return isSafe ? new SafeCall(span, sourceSpan, receiver, args, argumentSpan) :
             new Call(span, sourceSpan, receiver, args, argumentSpan);
     }
+    consumeOptionalAssignment() {
+        // When parsing assignment events (originating from two-way-binding aka banana-in-a-box syntax),
+        // it is valid for the primary expression to be terminated by the non-null operator. This
+        // primary expression is substituted as LHS of the assignment operator to achieve
+        // two-way-binding, such that the LHS could be the non-null operator. The grammar doesn't
+        // naturally allow for this syntax, so assignment events are parsed specially.
+        if ((this.parseFlags & 2 /* AssignmentEvent */) && this.next.isOperator('!') &&
+            this.peek(1).isOperator('=')) {
+            // First skip over the ! operator.
+            this.advance();
+            // Then skip over the = operator, to fully consume the optional assignment operator.
+            this.advance();
+            return true;
+        }
+        return this.consumeOptionalOperator('=');
+    }
     parseCallArguments() {
         if (this.next.isCharacter($RPAREN))
             return [];
@@ -10630,6 +10624,41 @@ class SimpleExpressionChecker extends RecursiveAstVisitor {
         this.errors.push('pipes');
     }
 }
+/**
+ * Computes the real offset in the original template for indexes in an interpolation.
+ *
+ * Because templates can have encoded HTML entities and the input passed to the parser at this stage
+ * of the compiler is the _decoded_ value, we need to compute the real offset using the original
+ * encoded values in the interpolated tokens. Note that this is only a special case handling for
+ * `MlParserTokenType.ENCODED_ENTITY` token types. All other interpolated tokens are expected to
+ * have parts which exactly match the input string for parsing the interpolation.
+ *
+ * @param interpolatedTokens The tokens for the interpolated value.
+ *
+ * @returns A map of index locations in the decoded template to indexes in the original template
+ */
+function getIndexMapForOriginalTemplate(interpolatedTokens) {
+    let offsetMap = new Map();
+    let consumedInOriginalTemplate = 0;
+    let consumedInInput = 0;
+    let tokenIndex = 0;
+    while (tokenIndex < interpolatedTokens.length) {
+        const currentToken = interpolatedTokens[tokenIndex];
+        if (currentToken.type === 9 /* ENCODED_ENTITY */) {
+            const [decoded, encoded] = currentToken.parts;
+            consumedInOriginalTemplate += encoded.length;
+            consumedInInput += decoded.length;
+        }
+        else {
+            const lengthOfParts = currentToken.parts.reduce((sum, current) => sum + current.length, 0);
+            consumedInInput += lengthOfParts;
+            consumedInOriginalTemplate += lengthOfParts;
+        }
+        offsetMap.set(consumedInInput, consumedInOriginalTemplate);
+        tokenIndex++;
+    }
+    return offsetMap;
+}
 
 /**
  * @license
@@ -13871,7 +13900,7 @@ class EscapedCharacterCursor extends PlainCharacterCursor {
         }
     }
     decodeHexDigits(start, length) {
-        const hex = this.input.substr(start.internalState.offset, length);
+        const hex = this.input.slice(start.internalState.offset, start.internalState.offset + length);
         const charCode = parseInt(hex, 16);
         if (!isNaN(charCode)) {
             return charCode;
@@ -15028,7 +15057,7 @@ class BindingParser {
                 // Regardless, neither of these values are used in Ivy but are only here to satisfy the
                 // function signature. This should likely be refactored in the future so that `sourceSpan`
                 // isn't being used inaccurately.
-                this.parseEvent(propName, expression, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
+                this.parseEvent(propName, expression, /* isAssignmentEvent */ false, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
             }
             else {
                 this._reportError(`Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
@@ -15036,11 +15065,11 @@ class BindingParser {
         }
         return targetEvents;
     }
-    parseInterpolation(value, sourceSpan) {
+    parseInterpolation(value, sourceSpan, interpolatedTokens) {
         const sourceInfo = sourceSpan.start.toString();
         const absoluteOffset = sourceSpan.fullStart.offset;
         try {
-            const ast = this._exprParser.parseInterpolation(value, sourceInfo, absoluteOffset, this._interpolationConfig);
+            const ast = this._exprParser.parseInterpolation(value, sourceInfo, absoluteOffset, interpolatedTokens, this._interpolationConfig);
             if (ast)
                 this._reportExpressionParserErrors(ast.errors, sourceSpan);
             return ast;
@@ -15177,8 +15206,8 @@ class BindingParser {
             this._parsePropertyAst(name, this._parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
     }
-    parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
-        const expr = this.parseInterpolation(value, valueSpan || sourceSpan);
+    parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
+        const expr = this.parseInterpolation(value, valueSpan || sourceSpan, interpolatedTokens);
         if (expr) {
             this._parsePropertyAst(name, expr, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
             return true;
@@ -15265,30 +15294,30 @@ class BindingParser {
         return new BoundElementProperty(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
     }
     // TODO: keySpan should be required but was made optional to avoid changing VE parser.
-    parseEvent(name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+    parseEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
         if (name.length === 0) {
             this._reportError(`Event name is missing in binding`, sourceSpan);
         }
         if (isAnimationLabel(name)) {
-            name = name.substr(1);
+            name = name.slice(1);
             if (keySpan !== undefined) {
                 keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
             }
-            this._parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
+            this._parseAnimationEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetEvents, keySpan);
         }
         else {
-            this._parseRegularEvent(name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
+            this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
         }
     }
     calcPossibleSecurityContexts(selector, propName, isAttribute) {
         const prop = this._schemaRegistry.getMappedPropName(propName);
         return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
     }
-    _parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
+    _parseAnimationEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetEvents, keySpan) {
         const matches = splitAtPeriod(name, [name, '']);
         const eventName = matches[0];
         const phase = matches[1].toLowerCase();
-        const ast = this._parseAction(expression, handlerSpan);
+        const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
         targetEvents.push(new ParsedEvent(eventName, phase, 1 /* Animation */, ast, sourceSpan, handlerSpan, keySpan));
         if (eventName.length === 0) {
             this._reportError(`Animation event name is missing in binding`, sourceSpan);
@@ -15302,20 +15331,20 @@ class BindingParser {
             this._reportError(`The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`, sourceSpan);
         }
     }
-    _parseRegularEvent(name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+    _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
         // long format: 'target: eventName'
         const [target, eventName] = splitAtColon(name, [null, name]);
-        const ast = this._parseAction(expression, handlerSpan);
+        const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
         targetMatchableAttrs.push([name, ast.source]);
         targetEvents.push(new ParsedEvent(eventName, target, 0 /* Regular */, ast, sourceSpan, handlerSpan, keySpan));
         // Don't detect directives for event names for now,
         // so don't add the event name to the matchableAttrs
     }
-    _parseAction(value, sourceSpan) {
+    _parseAction(value, isAssignmentEvent, sourceSpan) {
         const sourceInfo = (sourceSpan && sourceSpan.start || '(unknown').toString();
         const absoluteOffset = (sourceSpan && sourceSpan.start) ? sourceSpan.start.offset : 0;
         try {
-            const ast = this._exprParser.parseAction(value, sourceInfo, absoluteOffset, this._interpolationConfig);
+            const ast = this._exprParser.parseAction(value, isAssignmentEvent, sourceInfo, absoluteOffset, this._interpolationConfig);
             if (ast) {
                 this._reportExpressionParserErrors(ast.errors, sourceSpan);
             }
@@ -15675,7 +15704,7 @@ class HtmlAstToIvyAst {
         return new TextAttribute(attribute.name, attribute.value, attribute.sourceSpan, attribute.keySpan, attribute.valueSpan, attribute.i18n);
     }
     visitText(text) {
-        return this._visitTextWithInterpolation(text.value, text.sourceSpan, text.i18n);
+        return this._visitTextWithInterpolation(text.value, text.sourceSpan, text.tokens, text.i18n);
     }
     visitExpansion(expansion) {
         if (!expansion.i18n) {
@@ -15705,7 +15734,7 @@ class HtmlAstToIvyAst {
                 vars[formattedKey] = new BoundText(ast, value.sourceSpan);
             }
             else {
-                placeholders[key] = this._visitTextWithInterpolation(value.text, value.sourceSpan);
+                placeholders[key] = this._visitTextWithInterpolation(value.text, value.sourceSpan, null);
             }
         });
         return new Icu$1(vars, placeholders, expansion.sourceSpan, message);
@@ -15739,6 +15768,7 @@ class HtmlAstToIvyAst {
         return { bound, literal };
     }
     parseAttribute(isTemplateElement, attribute, matchableAttributes, parsedProperties, boundEvents, variables, references) {
+        var _a;
         const name = normalizeAttributeName(attribute.name);
         const value = attribute.value;
         const srcSpan = attribute.sourceSpan;
@@ -15777,7 +15807,7 @@ class HtmlAstToIvyAst {
                 const events = [];
                 const identifier = bindParts[IDENT_KW_IDX];
                 const keySpan = createKeySpan(srcSpan, bindParts[KW_ON_IDX], identifier);
-                this.bindingParser.parseEvent(identifier, value, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
+                this.bindingParser.parseEvent(identifier, value, /* isAssignmentEvent */ false, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
                 addEvents(events, boundEvents);
             }
             else if (bindParts[KW_BINDON_IDX]) {
@@ -15821,19 +15851,19 @@ class HtmlAstToIvyAst {
             }
             else {
                 const events = [];
-                this.bindingParser.parseEvent(identifier, value, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
+                this.bindingParser.parseEvent(identifier, value, /* isAssignmentEvent */ false, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan);
                 addEvents(events, boundEvents);
             }
             return true;
         }
         // No explicit binding found.
         const keySpan = createKeySpan(srcSpan, '' /* prefix */, name);
-        const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan);
+        const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan, (_a = attribute.valueTokens) !== null && _a !== void 0 ? _a : null);
         return hasBinding;
     }
-    _visitTextWithInterpolation(value, sourceSpan, i18n) {
+    _visitTextWithInterpolation(value, sourceSpan, interpolatedTokens, i18n) {
         const valueNoNgsp = replaceNgsp(value);
-        const expr = this.bindingParser.parseInterpolation(valueNoNgsp, sourceSpan);
+        const expr = this.bindingParser.parseInterpolation(valueNoNgsp, sourceSpan, interpolatedTokens);
         return expr ? new BoundText(expr, sourceSpan, i18n) : new Text$3(valueNoNgsp, sourceSpan);
     }
     parseVariable(identifier, value, sourceSpan, keySpan, valueSpan, variables) {
@@ -15859,7 +15889,7 @@ class HtmlAstToIvyAst {
     }
     parseAssignmentEvent(name, expression, sourceSpan, valueSpan, targetMatchableAttrs, boundEvents, keySpan) {
         const events = [];
-        this.bindingParser.parseEvent(`${name}Change`, `${expression}=$event`, sourceSpan, valueSpan || sourceSpan, targetMatchableAttrs, events, keySpan);
+        this.bindingParser.parseEvent(`${name}Change`, `${expression} =$event`, /* isAssignmentEvent */ true, sourceSpan, valueSpan || sourceSpan, targetMatchableAttrs, events, keySpan);
         addEvents(events, boundEvents);
     }
     reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
@@ -16648,7 +16678,8 @@ class I18nMetaVisitor {
      */
     _parseMetadata(meta) {
         return typeof meta === 'string' ? parseI18nMeta(meta) :
-            meta instanceof Message ? meta : {};
+            meta instanceof Message ? meta :
+                {};
     }
     /**
      * Generate (or restore) message id if not specified already.
@@ -16673,9 +16704,9 @@ class I18nMetaVisitor {
             // `packages/compiler/src/render3/view/template.ts`).
             // In that case we want to reuse the legacy message generated in the 1st pass (see
             // `setI18nRefs()`).
-            const previousMessage = meta instanceof Message ?
-                meta :
-                meta instanceof IcuPlaceholder ? meta.previousMessage : undefined;
+            const previousMessage = meta instanceof Message ? meta :
+                meta instanceof IcuPlaceholder ? meta.previousMessage :
+                    undefined;
             message.legacyIds = previousMessage ? previousMessage.legacyIds : [];
         }
     }
@@ -16720,10 +16751,14 @@ function i18nMetaToJSDoc(meta) {
     if (meta.description) {
         tags.push({ tagName: "desc" /* Desc */, text: meta.description });
     }
+    else {
+        // Suppress the JSCompiler warning that a `@desc` was not given for this message.
+        tags.push({ tagName: "suppress" /* Suppress */, text: '{msgDescriptions}' });
+    }
     if (meta.meaning) {
         tags.push({ tagName: "meaning" /* Meaning */, text: meta.meaning });
     }
-    return tags.length == 0 ? null : jsDocComment(tags);
+    return jsDocComment(tags);
 }
 
 /** Closure uses `goog.getMsg(message)` to lookup translations */
@@ -16741,10 +16776,7 @@ function createGoogleGetMsgStatements(variable$1, message, closureVar, params) {
     // const MSG_... = goog.getMsg(..);
     // I18N_X = MSG_...;
     const googGetMsgStmt = closureVar.set(variable(GOOG_GET_MSG).callFn(args)).toConstDecl();
-    const metaComment = i18nMetaToJSDoc(message);
-    if (metaComment !== null) {
-        googGetMsgStmt.addLeadingComment(metaComment);
-    }
+    googGetMsgStmt.addLeadingComment(i18nMetaToJSDoc(message));
     const i18nAssignmentStmt = new ExpressionStatement(variable$1.set(closureVar));
     return [googGetMsgStmt, i18nAssignmentStmt];
 }
@@ -16906,7 +16938,7 @@ const NG_PROJECT_AS_ATTR_NAME = 'ngProjectAs';
 // Global symbols available only inside event bindings.
 const EVENT_BINDING_SCOPE_GLOBALS = new Set(['$event']);
 // List of supported global targets for event listeners
-const GLOBAL_TARGET_RESOLVERS = new Map([['window', Identifiers$1.resolveWindow], ['document', Identifiers$1.resolveDocument], ['body', Identifiers$1.resolveBody]]);
+const GLOBAL_TARGET_RESOLVERS = new Map([['window', Identifiers.resolveWindow], ['document', Identifiers.resolveDocument], ['body', Identifiers.resolveBody]]);
 const LEADING_TRIVIA_CHARS = [' ', '\n', '\r', '\t'];
 //  if (rf & flags) { .. }
 function renderFlagCheckIfStmt(flags, statements) {
@@ -16923,15 +16955,29 @@ function prepareEventListenerParameters(eventAst, handlerName = null, scope = nu
     const implicitReceiverExpr = (scope === null || scope.bindingLevel === 0) ?
         variable(CONTEXT_NAME) :
         scope.getOrCreateSharedContextVar(0);
-    const bindingStatements = convertActionBinding(scope, implicitReceiverExpr, handler, 'b', () => error('Unexpected interpolation'), eventAst.handlerSpan, implicitReceiverAccesses, EVENT_BINDING_SCOPE_GLOBALS);
+    const bindingStatements = convertActionBinding(scope, implicitReceiverExpr, handler, 'b', eventAst.handlerSpan, implicitReceiverAccesses, EVENT_BINDING_SCOPE_GLOBALS);
     const statements = [];
-    if (scope) {
+    const variableDeclarations = scope === null || scope === void 0 ? void 0 : scope.variableDeclarations();
+    const restoreViewStatement = scope === null || scope === void 0 ? void 0 : scope.restoreViewStatement();
+    if (variableDeclarations) {
         // `variableDeclarations` needs to run first, because
         // `restoreViewStatement` depends on the result.
-        statements.push(...scope.variableDeclarations());
-        statements.unshift(...scope.restoreViewStatement());
+        statements.push(...variableDeclarations);
     }
     statements.push(...bindingStatements);
+    if (restoreViewStatement) {
+        statements.unshift(restoreViewStatement);
+        // If there's a `restoreView` call, we need to reset the view at the end of the listener
+        // in order to avoid a leak. If there's a `return` statement already, we wrap it in the
+        // call, e.g. `return resetView(ctx.foo())`. Otherwise we add the call as the last statement.
+        const lastStatement = statements[statements.length - 1];
+        if (lastStatement instanceof ReturnStatement) {
+            statements[statements.length - 1] = new ReturnStatement(invokeInstruction(lastStatement.value.sourceSpan, Identifiers.resetView, [lastStatement.value]));
+        }
+        else {
+            statements.push(new ExpressionStatement(invokeInstruction(null, Identifiers.resetView, [])));
+        }
+    }
     const eventName = type === 1 /* Animation */ ? prepareSyntheticListenerName(name, phase) : name;
     const fnName = handlerName && sanitizeIdentifier(handlerName);
     const fnArgs = [];
@@ -17018,12 +17064,12 @@ class TemplateDefinitionBuilder {
         this.fileBasedI18nSuffix = relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_') + '_';
         this._valueConverter = new ValueConverter(constantPool, () => this.allocateDataSlot(), (numSlots) => this.allocatePureFunctionSlots(numSlots), (name, localName, slot, value) => {
             this._bindingScope.set(this.level, localName, value);
-            this.creationInstruction(null, Identifiers$1.pipe, [literal(slot), literal(name)]);
+            this.creationInstruction(null, Identifiers.pipe, [literal(slot), literal(name)]);
         });
     }
     buildTemplateFunction(nodes, variables, ngContentSelectorsOffset = 0, i18n) {
         this._ngContentSelectorsOffset = ngContentSelectorsOffset;
-        if (this._namespace !== Identifiers$1.namespaceHTML) {
+        if (this._namespace !== Identifiers.namespaceHTML) {
             this.creationInstruction(null, this._namespace);
         }
         // Create variable bindings
@@ -17069,15 +17115,15 @@ class TemplateDefinitionBuilder {
             // Since we accumulate ngContent selectors while processing template elements,
             // we *prepend* `projectionDef` to creation instructions block, to put it before
             // any `projection` instructions
-            this.creationInstruction(null, Identifiers$1.projectionDef, parameters, /* prepend */ true);
+            this.creationInstruction(null, Identifiers.projectionDef, parameters, /* prepend */ true);
         }
         if (initI18nContext) {
             this.i18nEnd(null, selfClosingI18nInstruction);
         }
         // Generate all the creation mode instructions (e.g. resolve bindings in listeners)
-        const creationStatements = this._creationCodeFns.map((fn) => fn());
+        const creationStatements = getInstructionStatements(this._creationCodeFns);
         // Generate all the update mode instructions (e.g. resolve property or text bindings)
-        const updateStatements = this._updateCodeFns.map((fn) => fn());
+        const updateStatements = getInstructionStatements(this._updateCodeFns);
         //  Variable declaration must occur after binding resolution so we can generate context
         //  instructions that build on each other.
         // e.g. const b = nextContext().$implicit(); const b = nextContext();
@@ -17230,7 +17276,7 @@ class TemplateDefinitionBuilder {
                     if (Object.keys(icuMapping).length) {
                         args.push(mapLiteral(icuMapping, true));
                     }
-                    return instruction(null, Identifiers$1.i18nPostprocess, args);
+                    return invokeInstruction(null, Identifiers.i18nPostprocess, args);
                 };
             }
             this.i18nTranslate(meta, params, context.ref, transformFn);
@@ -17249,7 +17295,7 @@ class TemplateDefinitionBuilder {
             // into i18nStart call for top level i18n context
             params.push(literal(id));
         }
-        this.creationInstruction(span, selfClosing ? Identifiers$1.i18n : Identifiers$1.i18nStart, params);
+        this.creationInstruction(span, selfClosing ? Identifiers.i18n : Identifiers.i18nStart, params);
     }
     i18nEnd(span = null, selfClosing) {
         if (!this.i18n) {
@@ -17265,25 +17311,22 @@ class TemplateDefinitionBuilder {
         // setup accumulated bindings
         const { index, bindings } = this.i18n;
         if (bindings.size) {
-            const chainBindings = [];
-            bindings.forEach(binding => {
-                chainBindings.push({ sourceSpan: span, value: () => this.convertPropertyBinding(binding) });
-            });
-            // for i18n block, advance to the most recent element index (by taking the current number of
-            // elements and subtracting one) before invoking `i18nExp` instructions, to make sure the
-            // necessary lifecycle hooks of components/directives are properly flushed.
-            this.updateInstructionChainWithAdvance(this.getConstCount() - 1, Identifiers$1.i18nExp, chainBindings);
-            this.updateInstruction(span, Identifiers$1.i18nApply, [literal(index)]);
+            for (const binding of bindings) {
+                // for i18n block, advance to the most recent element index (by taking the current number of
+                // elements and subtracting one) before invoking `i18nExp` instructions, to make sure the
+                // necessary lifecycle hooks of components/directives are properly flushed.
+                this.updateInstructionWithAdvance(this.getConstCount() - 1, span, Identifiers.i18nExp, () => this.convertPropertyBinding(binding));
+            }
+            this.updateInstruction(span, Identifiers.i18nApply, [literal(index)]);
         }
         if (!selfClosing) {
-            this.creationInstruction(span, Identifiers$1.i18nEnd);
+            this.creationInstruction(span, Identifiers.i18nEnd);
         }
         this.i18n = null; // reset local i18n context
     }
     i18nAttributesInstruction(nodeIndex, attrs, sourceSpan) {
         let hasBindings = false;
         const i18nAttrArgs = [];
-        const bindings = [];
         attrs.forEach(attr => {
             const message = attr.i18n;
             const converted = attr.value.visit(this._valueConverter);
@@ -17294,33 +17337,27 @@ class TemplateDefinitionBuilder {
                 i18nAttrArgs.push(literal(attr.name), this.i18nTranslate(message, params));
                 converted.expressions.forEach(expression => {
                     hasBindings = true;
-                    bindings.push({
-                        sourceSpan,
-                        value: () => this.convertPropertyBinding(expression),
-                    });
+                    this.updateInstructionWithAdvance(nodeIndex, sourceSpan, Identifiers.i18nExp, () => this.convertPropertyBinding(expression));
                 });
             }
         });
-        if (bindings.length > 0) {
-            this.updateInstructionChainWithAdvance(nodeIndex, Identifiers$1.i18nExp, bindings);
-        }
         if (i18nAttrArgs.length > 0) {
             const index = literal(this.allocateDataSlot());
             const constIndex = this.addToConsts(literalArr(i18nAttrArgs));
-            this.creationInstruction(sourceSpan, Identifiers$1.i18nAttributes, [index, constIndex]);
+            this.creationInstruction(sourceSpan, Identifiers.i18nAttributes, [index, constIndex]);
             if (hasBindings) {
-                this.updateInstruction(sourceSpan, Identifiers$1.i18nApply, [index]);
+                this.updateInstruction(sourceSpan, Identifiers.i18nApply, [index]);
             }
         }
     }
     getNamespaceInstruction(namespaceKey) {
         switch (namespaceKey) {
             case 'math':
-                return Identifiers$1.namespaceMathML;
+                return Identifiers.namespaceMathML;
             case 'svg':
-                return Identifiers$1.namespaceSVG;
+                return Identifiers.namespaceSVG;
             default:
-                return Identifiers$1.namespaceHTML;
+                return Identifiers.namespaceHTML;
         }
     }
     addNamespaceInstruction(nsInstruction, element) {
@@ -17347,7 +17384,7 @@ class TemplateDefinitionBuilder {
         else if (projectionSlotIdx !== 0) {
             parameters.push(literal(projectionSlotIdx));
         }
-        this.creationInstruction(ngContent.sourceSpan, Identifiers$1.projection, parameters);
+        this.creationInstruction(ngContent.sourceSpan, Identifiers.projection, parameters);
         if (this.i18n) {
             this.i18n.appendProjection(ngContent.i18n, slot);
         }
@@ -17420,23 +17457,21 @@ class TemplateDefinitionBuilder {
             element.outputs.length === 0 && boundI18nAttrs.length === 0 && !hasChildren;
         const createSelfClosingI18nInstruction = !createSelfClosingInstruction && hasTextChildrenOnly(element.children);
         if (createSelfClosingInstruction) {
-            this.creationInstruction(element.sourceSpan, isNgContainer$1 ? Identifiers$1.elementContainer : Identifiers$1.element, trimTrailingNulls(parameters));
+            this.creationInstruction(element.sourceSpan, isNgContainer$1 ? Identifiers.elementContainer : Identifiers.element, trimTrailingNulls(parameters));
         }
         else {
-            this.creationInstruction(element.startSourceSpan, isNgContainer$1 ? Identifiers$1.elementContainerStart : Identifiers$1.elementStart, trimTrailingNulls(parameters));
+            this.creationInstruction(element.startSourceSpan, isNgContainer$1 ? Identifiers.elementContainerStart : Identifiers.elementStart, trimTrailingNulls(parameters));
             if (isNonBindableMode) {
-                this.creationInstruction(element.startSourceSpan, Identifiers$1.disableBindings);
+                this.creationInstruction(element.startSourceSpan, Identifiers.disableBindings);
             }
             if (boundI18nAttrs.length > 0) {
                 this.i18nAttributesInstruction(elementIndex, boundI18nAttrs, (_a = element.startSourceSpan) !== null && _a !== void 0 ? _a : element.sourceSpan);
             }
             // Generate Listeners (outputs)
             if (element.outputs.length > 0) {
-                const listeners = element.outputs.map((outputAst) => ({
-                    sourceSpan: outputAst.sourceSpan,
-                    params: this.prepareListenerParameter(element.name, outputAst, elementIndex)
-                }));
-                this.creationInstructionChain(Identifiers$1.listener, listeners);
+                for (const outputAst of element.outputs) {
+                    this.creationInstruction(outputAst.sourceSpan, Identifiers.listener, this.prepareListenerParameter(element.name, outputAst, elementIndex));
+                }
             }
             // Note: it's important to keep i18n/i18nStart instructions after i18nAttributes and
             // listeners, to make sure i18nAttributes instruction targets current element at runtime.
@@ -17477,9 +17512,8 @@ class TemplateDefinitionBuilder {
                 const hasValue = value instanceof LiteralPrimitive ? !!value.value : true;
                 this.allocateBindingSlots(value);
                 propertyBindings.push({
-                    name: prepareSyntheticPropertyName(input.name),
-                    sourceSpan: input.sourceSpan,
-                    value: () => hasValue ? this.convertPropertyBinding(value) : emptyValueBindInstruction
+                    span: input.sourceSpan,
+                    paramsOrFn: getBindingFunctionParams(() => hasValue ? this.convertPropertyBinding(value) : emptyValueBindInstruction, prepareSyntheticPropertyName(input.name))
                 });
             }
             else {
@@ -17516,10 +17550,8 @@ class TemplateDefinitionBuilder {
                             // [prop]="value"
                             // Collect all the properties so that we can chain into a single function at the end.
                             propertyBindings.push({
-                                name: attrName,
-                                sourceSpan: input.sourceSpan,
-                                value: () => this.convertPropertyBinding(value),
-                                params
+                                span: input.sourceSpan,
+                                paramsOrFn: getBindingFunctionParams(() => this.convertPropertyBinding(value), attrName, params)
                             });
                         }
                     }
@@ -17533,16 +17565,14 @@ class TemplateDefinitionBuilder {
                             // [attr.name]="value" or attr.name="{{value}}"
                             // Collect the attribute bindings so that they can be chained at the end.
                             attributeBindings.push({
-                                name: attrName,
-                                sourceSpan: input.sourceSpan,
-                                value: () => this.convertPropertyBinding(boundValue),
-                                params
+                                span: input.sourceSpan,
+                                paramsOrFn: getBindingFunctionParams(() => this.convertPropertyBinding(boundValue), attrName, params)
                             });
                         }
                     }
                     else {
                         // class prop
-                        this.updateInstructionWithAdvance(elementIndex, input.sourceSpan, Identifiers$1.classProp, () => {
+                        this.updateInstructionWithAdvance(elementIndex, input.sourceSpan, Identifiers.classProp, () => {
                             return [
                                 literal(elementIndex), literal(attrName), this.convertPropertyBinding(value),
                                 ...params
@@ -17552,11 +17582,11 @@ class TemplateDefinitionBuilder {
                 }
             }
         });
-        if (propertyBindings.length > 0) {
-            this.updateInstructionChainWithAdvance(elementIndex, Identifiers$1.property, propertyBindings);
+        for (const propertyBinding of propertyBindings) {
+            this.updateInstructionWithAdvance(elementIndex, propertyBinding.span, Identifiers.property, propertyBinding.paramsOrFn);
         }
-        if (attributeBindings.length > 0) {
-            this.updateInstructionChainWithAdvance(elementIndex, Identifiers$1.attribute, attributeBindings);
+        for (const attributeBinding of attributeBindings) {
+            this.updateInstructionWithAdvance(elementIndex, attributeBinding.span, Identifiers.attribute, attributeBinding.paramsOrFn);
         }
         // Traverse element child nodes
         visitAll$1(this, element.children);
@@ -17570,9 +17600,9 @@ class TemplateDefinitionBuilder {
                 this.i18nEnd(span, createSelfClosingI18nInstruction);
             }
             if (isNonBindableMode) {
-                this.creationInstruction(span, Identifiers$1.enableBindings);
+                this.creationInstruction(span, Identifiers.enableBindings);
             }
-            this.creationInstruction(span, isNgContainer$1 ? Identifiers$1.elementContainerEnd : Identifiers$1.elementEnd);
+            this.creationInstruction(span, isNgContainer$1 ? Identifiers.elementContainerEnd : Identifiers.elementEnd);
         }
     }
     visitTemplate(template) {
@@ -17599,7 +17629,7 @@ class TemplateDefinitionBuilder {
         if (template.references && template.references.length) {
             const refs = this.prepareRefsArray(template.references);
             parameters.push(this.addToConsts(refs));
-            parameters.push(importExpr(Identifiers$1.templateRefExtractor));
+            parameters.push(importExpr(Identifiers.templateRefExtractor));
         }
         // Create the template function
         const templateVisitor = new TemplateDefinitionBuilder(this.constantPool, this._bindingScope, this.level + 1, contextName, this.i18n, templateIndex, templateName, this._namespace, this.fileBasedI18nSuffix, this.i18nUseExternalIds, this._constants);
@@ -17615,7 +17645,7 @@ class TemplateDefinitionBuilder {
             }
         });
         // e.g. template(1, MyComp_Template_1)
-        this.creationInstruction(template.sourceSpan, Identifiers$1.templateCreate, () => {
+        this.creationInstruction(template.sourceSpan, Identifiers.templateCreate, () => {
             parameters.splice(2, 0, literal(templateVisitor.getConstCount()), literal(templateVisitor.getVarCount()));
             return trimTrailingNulls(parameters);
         });
@@ -17636,12 +17666,8 @@ class TemplateDefinitionBuilder {
                 this.templatePropertyBindings(templateIndex, inputs);
             }
             // Generate listeners for directive output
-            if (template.outputs.length > 0) {
-                const listeners = template.outputs.map((outputAst) => ({
-                    sourceSpan: outputAst.sourceSpan,
-                    params: this.prepareListenerParameter('ng_template', outputAst, templateIndex)
-                }));
-                this.creationInstructionChain(Identifiers$1.listener, listeners);
+            for (const outputAst of template.outputs) {
+                this.creationInstruction(outputAst.sourceSpan, Identifiers.listener, this.prepareListenerParameter('ng_template', outputAst, templateIndex));
             }
         }
     }
@@ -17656,7 +17682,7 @@ class TemplateDefinitionBuilder {
             return;
         }
         const nodeIndex = this.allocateDataSlot();
-        this.creationInstruction(text.sourceSpan, Identifiers$1.text, [literal(nodeIndex)]);
+        this.creationInstruction(text.sourceSpan, Identifiers.text, [literal(nodeIndex)]);
         const value = text.value.visit(this._valueConverter);
         this.allocateBindingSlots(value);
         if (value instanceof Interpolation) {
@@ -17671,7 +17697,7 @@ class TemplateDefinitionBuilder {
         // block, we exclude this text element from instructions set,
         // since it will be captured in i18n content and processed at runtime
         if (!this.i18n) {
-            this.creationInstruction(text.sourceSpan, Identifiers$1.text, [literal(this.allocateDataSlot()), literal(text.value)]);
+            this.creationInstruction(text.sourceSpan, Identifiers.text, [literal(this.allocateDataSlot()), literal(text.value)]);
         }
     }
     visitIcu(icu) {
@@ -17696,7 +17722,7 @@ class TemplateDefinitionBuilder {
         const transformFn = (raw) => {
             const params = Object.assign(Object.assign({}, vars), placeholders);
             const formatted = i18nFormatPlaceholderNames(params, /* useCamelCase */ false);
-            return instruction(null, Identifiers$1.i18nPostprocess, [raw, mapLiteral(formatted, true)]);
+            return invokeInstruction(null, Identifiers.i18nPostprocess, [raw, mapLiteral(formatted, true)]);
         };
         // in case the whole i18n message is a single ICU - we do not need to
         // create a separate top-level translation, we can use the root ref instead
@@ -17738,32 +17764,33 @@ class TemplateDefinitionBuilder {
     }
     templatePropertyBindings(templateIndex, attrs) {
         const propertyBindings = [];
-        attrs.forEach(input => {
-            if (input instanceof BoundAttribute) {
-                const value = input.value.visit(this._valueConverter);
-                if (value !== undefined) {
-                    this.allocateBindingSlots(value);
-                    if (value instanceof Interpolation) {
-                        // Params typically contain attribute namespace and value sanitizer, which is applicable
-                        // for regular HTML elements, but not applicable for <ng-template> (since props act as
-                        // inputs to directives), so keep params array empty.
-                        const params = [];
-                        // prop="{{value}}" case
-                        this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value), templateIndex, input.name, input, value, params);
-                    }
-                    else {
-                        // [prop]="value" case
-                        propertyBindings.push({
-                            name: input.name,
-                            sourceSpan: input.sourceSpan,
-                            value: () => this.convertPropertyBinding(value)
-                        });
-                    }
-                }
+        for (const input of attrs) {
+            if (!(input instanceof BoundAttribute)) {
+                continue;
             }
-        });
-        if (propertyBindings.length > 0) {
-            this.updateInstructionChainWithAdvance(templateIndex, Identifiers$1.property, propertyBindings);
+            const value = input.value.visit(this._valueConverter);
+            if (value === undefined) {
+                continue;
+            }
+            this.allocateBindingSlots(value);
+            if (value instanceof Interpolation) {
+                // Params typically contain attribute namespace and value sanitizer, which is applicable
+                // for regular HTML elements, but not applicable for <ng-template> (since props act as
+                // inputs to directives), so keep params array empty.
+                const params = [];
+                // prop="{{value}}" case
+                this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value), templateIndex, input.name, input, value, params);
+            }
+            else {
+                // [prop]="value" case
+                propertyBindings.push({
+                    span: input.sourceSpan,
+                    paramsOrFn: getBindingFunctionParams(() => this.convertPropertyBinding(value), input.name)
+                });
+            }
+        }
+        for (const propertyBinding of propertyBindings) {
+            this.updateInstructionWithAdvance(templateIndex, propertyBinding.span, Identifiers.property, propertyBinding.paramsOrFn);
         }
     }
     // Bindings must only be resolved after all local refs have been visited, so all
@@ -17771,39 +17798,23 @@ class TemplateDefinitionBuilder {
     // Otherwise, we wouldn't be able to support local refs that are defined after their
     // bindings. e.g. {{ foo }} <div #foo></div>
     instructionFn(fns, span, reference, paramsOrFn, prepend = false) {
-        fns[prepend ? 'unshift' : 'push'](() => {
-            const params = Array.isArray(paramsOrFn) ? paramsOrFn : paramsOrFn();
-            return instruction(span, reference, params).toStmt();
-        });
+        fns[prepend ? 'unshift' : 'push']({ span, reference, paramsOrFn });
     }
     processStylingUpdateInstruction(elementIndex, instruction) {
         let allocateBindingSlots = 0;
         if (instruction) {
-            const calls = [];
-            instruction.calls.forEach(call => {
+            for (const call of instruction.calls) {
                 allocateBindingSlots += call.allocateBindingSlots;
-                calls.push({
-                    sourceSpan: call.sourceSpan,
-                    value: () => {
-                        return call.params(value => (call.supportsInterpolation && value instanceof Interpolation) ?
-                            this.getUpdateInstructionArguments(value) :
-                            this.convertPropertyBinding(value));
-                    }
-                });
-            });
-            this.updateInstructionChainWithAdvance(elementIndex, instruction.reference, calls);
+                this.updateInstructionWithAdvance(elementIndex, call.sourceSpan, instruction.reference, () => call.params(value => (call.supportsInterpolation && value instanceof Interpolation) ?
+                    this.getUpdateInstructionArguments(value) :
+                    this.convertPropertyBinding(value)));
+            }
         }
         return allocateBindingSlots;
     }
     creationInstruction(span, reference, paramsOrFn, prepend) {
         this.instructionFn(this._creationCodeFns, span, reference, paramsOrFn || [], prepend);
     }
-    creationInstructionChain(reference, calls) {
-        const span = calls.length ? calls[0].sourceSpan : null;
-        this._creationCodeFns.push(() => {
-            return chainedInstruction(reference, calls.map(call => call.params()), span).toStmt();
-        });
-    }
     updateInstructionWithAdvance(nodeIndex, span, reference, paramsOrFn) {
         this.addAdvanceInstructionIfNecessary(nodeIndex, span);
         this.updateInstruction(span, reference, paramsOrFn);
@@ -17811,35 +17822,13 @@ class TemplateDefinitionBuilder {
     updateInstruction(span, reference, paramsOrFn) {
         this.instructionFn(this._updateCodeFns, span, reference, paramsOrFn || []);
     }
-    updateInstructionChain(reference, bindings) {
-        const span = bindings.length ? bindings[0].sourceSpan : null;
-        this._updateCodeFns.push(() => {
-            const calls = bindings.map(property => {
-                const value = property.value();
-                const fnParams = Array.isArray(value) ? value : [value];
-                if (property.params) {
-                    fnParams.push(...property.params);
-                }
-                if (property.name) {
-                    // We want the property name to always be the first function parameter.
-                    fnParams.unshift(literal(property.name));
-                }
-                return fnParams;
-            });
-            return chainedInstruction(reference, calls, span).toStmt();
-        });
-    }
-    updateInstructionChainWithAdvance(nodeIndex, reference, bindings) {
-        this.addAdvanceInstructionIfNecessary(nodeIndex, bindings.length ? bindings[0].sourceSpan : null);
-        this.updateInstructionChain(reference, bindings);
-    }
     addAdvanceInstructionIfNecessary(nodeIndex, span) {
         if (nodeIndex !== this._currentIndex) {
             const delta = nodeIndex - this._currentIndex;
             if (delta < 1) {
                 throw new Error('advance instruction can only go forwards');
             }
-            this.instructionFn(this._updateCodeFns, span, Identifiers$1.advance, [literal(delta)]);
+            this.instructionFn(this._updateCodeFns, span, Identifiers.advance, [literal(delta)]);
             this._currentIndex = nodeIndex;
         }
     }
@@ -17864,7 +17853,7 @@ class TemplateDefinitionBuilder {
             this._bindingScope.getOrCreateSharedContextVar(0);
     }
     convertPropertyBinding(value) {
-        const convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext(), () => error('Unexpected interpolation'));
+        const convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext());
         const valExpr = convertedPropertyBinding.currValExpr;
         this._tempVariables.push(...convertedPropertyBinding.stmts);
         return valExpr;
@@ -18021,7 +18010,7 @@ class TemplateDefinitionBuilder {
                 // e.g. nextContext(2);
                 const nextContextStmt = relativeLevel > 0 ? [generateNextContextExpr(relativeLevel).toStmt()] : [];
                 // e.g. const $foo$ = reference(1);
-                const refExpr = lhs.set(importExpr(Identifiers$1.reference).callFn([literal(slot)]));
+                const refExpr = lhs.set(importExpr(Identifiers.reference).callFn([literal(slot)]));
                 return nextContextStmt.concat(refExpr.toConstDecl());
             }, true);
             return [reference.name, reference.value];
@@ -18099,31 +18088,28 @@ class ValueConverter extends AstMemoryEfficientTransformer {
     }
 }
 // Pipes always have at least one parameter, the value they operate on
-const pipeBindingIdentifiers = [Identifiers$1.pipeBind1, Identifiers$1.pipeBind2, Identifiers$1.pipeBind3, Identifiers$1.pipeBind4];
+const pipeBindingIdentifiers = [Identifiers.pipeBind1, Identifiers.pipeBind2, Identifiers.pipeBind3, Identifiers.pipeBind4];
 function pipeBindingCallInfo(args) {
     const identifier = pipeBindingIdentifiers[args.length];
     return {
-        identifier: identifier || Identifiers$1.pipeBindV,
+        identifier: identifier || Identifiers.pipeBindV,
         isVarLength: !identifier,
     };
 }
 const pureFunctionIdentifiers = [
-    Identifiers$1.pureFunction0, Identifiers$1.pureFunction1, Identifiers$1.pureFunction2, Identifiers$1.pureFunction3, Identifiers$1.pureFunction4,
-    Identifiers$1.pureFunction5, Identifiers$1.pureFunction6, Identifiers$1.pureFunction7, Identifiers$1.pureFunction8
+    Identifiers.pureFunction0, Identifiers.pureFunction1, Identifiers.pureFunction2, Identifiers.pureFunction3, Identifiers.pureFunction4,
+    Identifiers.pureFunction5, Identifiers.pureFunction6, Identifiers.pureFunction7, Identifiers.pureFunction8
 ];
 function pureFunctionCallInfo(args) {
     const identifier = pureFunctionIdentifiers[args.length];
     return {
-        identifier: identifier || Identifiers$1.pureFunctionV,
+        identifier: identifier || Identifiers.pureFunctionV,
         isVarLength: !identifier,
     };
 }
-function instruction(span, reference, params) {
-    return importExpr(reference, null, span).callFn(params, span);
-}
 // e.g. x(2);
 function generateNextContextExpr(relativeLevelDiff) {
-    return importExpr(Identifiers$1.nextContext)
+    return importExpr(Identifiers.nextContext)
         .callFn(relativeLevelDiff > 1 ? [literal(relativeLevelDiff)] : []);
 }
 function getLiteralFactory(constantPool, literal$1, allocateSlots) {
@@ -18323,21 +18309,22 @@ class BindingScope {
         }
     }
     restoreViewStatement() {
-        const statements = [];
         if (this.restoreViewVariable) {
-            const restoreCall = instruction(null, Identifiers$1.restoreView, [this.restoreViewVariable]);
+            const restoreCall = invokeInstruction(null, Identifiers.restoreView, [this.restoreViewVariable]);
             // Either `const restoredCtx = restoreView($state$);` or `restoreView($state$);`
             // depending on whether it is being used.
-            statements.push(this.usesRestoredViewContext ?
+            return this.usesRestoredViewContext ?
                 variable(RESTORED_VIEW_CONTEXT_NAME).set(restoreCall).toConstDecl() :
-                restoreCall.toStmt());
+                restoreCall.toStmt();
         }
-        return statements;
+        return null;
     }
     viewSnapshotStatements() {
         // const $state$ = getCurrentView();
         return this.restoreViewVariable ?
-            [this.restoreViewVariable.set(instruction(null, Identifiers$1.getCurrentView, [])).toConstDecl()] :
+            [
+                this.restoreViewVariable.set(invokeInstruction(null, Identifiers.getCurrentView, [])).toConstDecl()
+            ] :
             [];
     }
     isListenerScope() {
@@ -18405,25 +18392,25 @@ function getNgProjectAsLiteral(attribute) {
 function getPropertyInterpolationExpression(interpolation) {
     switch (getInterpolationArgsLength(interpolation)) {
         case 1:
-            return Identifiers$1.propertyInterpolate;
+            return Identifiers.propertyInterpolate;
         case 3:
-            return Identifiers$1.propertyInterpolate1;
+            return Identifiers.propertyInterpolate1;
         case 5:
-            return Identifiers$1.propertyInterpolate2;
+            return Identifiers.propertyInterpolate2;
         case 7:
-            return Identifiers$1.propertyInterpolate3;
+            return Identifiers.propertyInterpolate3;
         case 9:
-            return Identifiers$1.propertyInterpolate4;
+            return Identifiers.propertyInterpolate4;
         case 11:
-            return Identifiers$1.propertyInterpolate5;
+            return Identifiers.propertyInterpolate5;
         case 13:
-            return Identifiers$1.propertyInterpolate6;
+            return Identifiers.propertyInterpolate6;
         case 15:
-            return Identifiers$1.propertyInterpolate7;
+            return Identifiers.propertyInterpolate7;
         case 17:
-            return Identifiers$1.propertyInterpolate8;
+            return Identifiers.propertyInterpolate8;
         default:
-            return Identifiers$1.propertyInterpolateV;
+            return Identifiers.propertyInterpolateV;
     }
 }
 /**
@@ -18433,23 +18420,23 @@ function getPropertyInterpolationExpression(interpolation) {
 function getAttributeInterpolationExpression(interpolation) {
     switch (getInterpolationArgsLength(interpolation)) {
         case 3:
-            return Identifiers$1.attributeInterpolate1;
+            return Identifiers.attributeInterpolate1;
         case 5:
-            return Identifiers$1.attributeInterpolate2;
+            return Identifiers.attributeInterpolate2;
         case 7:
-            return Identifiers$1.attributeInterpolate3;
+            return Identifiers.attributeInterpolate3;
         case 9:
-            return Identifiers$1.attributeInterpolate4;
+            return Identifiers.attributeInterpolate4;
         case 11:
-            return Identifiers$1.attributeInterpolate5;
+            return Identifiers.attributeInterpolate5;
         case 13:
-            return Identifiers$1.attributeInterpolate6;
+            return Identifiers.attributeInterpolate6;
         case 15:
-            return Identifiers$1.attributeInterpolate7;
+            return Identifiers.attributeInterpolate7;
         case 17:
-            return Identifiers$1.attributeInterpolate8;
+            return Identifiers.attributeInterpolate8;
         default:
-            return Identifiers$1.attributeInterpolateV;
+            return Identifiers.attributeInterpolateV;
     }
 }
 /**
@@ -18459,25 +18446,25 @@ function getAttributeInterpolationExpression(interpolation) {
 function getTextInterpolationExpression(interpolation) {
     switch (getInterpolationArgsLength(interpolation)) {
         case 1:
-            return Identifiers$1.textInterpolate;
+            return Identifiers.textInterpolate;
         case 3:
-            return Identifiers$1.textInterpolate1;
+            return Identifiers.textInterpolate1;
         case 5:
-            return Identifiers$1.textInterpolate2;
+            return Identifiers.textInterpolate2;
         case 7:
-            return Identifiers$1.textInterpolate3;
+            return Identifiers.textInterpolate3;
         case 9:
-            return Identifiers$1.textInterpolate4;
+            return Identifiers.textInterpolate4;
         case 11:
-            return Identifiers$1.textInterpolate5;
+            return Identifiers.textInterpolate5;
         case 13:
-            return Identifiers$1.textInterpolate6;
+            return Identifiers.textInterpolate6;
         case 15:
-            return Identifiers$1.textInterpolate7;
+            return Identifiers.textInterpolate7;
         case 17:
-            return Identifiers$1.textInterpolate8;
+            return Identifiers.textInterpolate8;
         default:
-            return Identifiers$1.textInterpolateV;
+            return Identifiers.textInterpolateV;
     }
 }
 /**
@@ -18568,18 +18555,18 @@ function makeBindingParser(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
 function resolveSanitizationFn(context, isAttribute) {
     switch (context) {
         case SecurityContext.HTML:
-            return importExpr(Identifiers$1.sanitizeHtml);
+            return importExpr(Identifiers.sanitizeHtml);
         case SecurityContext.SCRIPT:
-            return importExpr(Identifiers$1.sanitizeScript);
+            return importExpr(Identifiers.sanitizeScript);
         case SecurityContext.STYLE:
             // the compiler does not fill in an instruction for [style.prop?] binding
             // values because the style algorithm knows internally what props are subject
             // to sanitization (only [attr.style] values are explicitly sanitized)
-            return isAttribute ? importExpr(Identifiers$1.sanitizeStyle) : null;
+            return isAttribute ? importExpr(Identifiers.sanitizeStyle) : null;
         case SecurityContext.URL:
-            return importExpr(Identifiers$1.sanitizeUrl);
+            return importExpr(Identifiers.sanitizeUrl);
         case SecurityContext.RESOURCE_URL:
-            return importExpr(Identifiers$1.sanitizeResourceUrl);
+            return importExpr(Identifiers.sanitizeResourceUrl);
         default:
             return null;
     }
@@ -18589,10 +18576,10 @@ function trustedConstAttribute(tagName, attr) {
     if (isTrustedTypesSink(tagName, attr.name)) {
         switch (elementRegistry.securityContext(tagName, attr.name, /* isAttribute */ true)) {
             case SecurityContext.HTML:
-                return taggedTemplate(importExpr(Identifiers$1.trustConstantHtml), new TemplateLiteral([new TemplateLiteralElement(attr.value)], []), undefined, attr.valueSpan);
+                return taggedTemplate(importExpr(Identifiers.trustConstantHtml), new TemplateLiteral([new TemplateLiteralElement(attr.value)], []), undefined, attr.valueSpan);
             // NB: no SecurityContext.SCRIPT here, as the corresponding tags are stripped by the compiler.
             case SecurityContext.RESOURCE_URL:
-                return taggedTemplate(importExpr(Identifiers$1.trustConstantResourceUrl), new TemplateLiteral([new TemplateLiteralElement(attr.value)], []), undefined, attr.valueSpan);
+                return taggedTemplate(importExpr(Identifiers.trustConstantResourceUrl), new TemplateLiteral([new TemplateLiteralElement(attr.value)], []), undefined, attr.valueSpan);
             default:
                 return value;
         }
@@ -18610,6 +18597,20 @@ function isTextNode(node) {
 function hasTextChildrenOnly(children) {
     return children.every(isTextNode);
 }
+function getBindingFunctionParams(deferredParams, name, eagerParams) {
+    return () => {
+        const value = deferredParams();
+        const fnParams = Array.isArray(value) ? value : [value];
+        if (eagerParams) {
+            fnParams.push(...eagerParams);
+        }
+        if (name) {
+            // We want the property name to always be the first function parameter.
+            fnParams.unshift(literal(name));
+        }
+        return fnParams;
+    };
+}
 /** Name of the global variable that is used to determine if we use Closure translations or not */
 const NG_I18N_CLOSURE_MODE = 'ngI18nClosureMode';
 /**
@@ -18706,6 +18707,9 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     if (meta.exportAs !== null) {
         definitionMap.set('exportAs', literalArr(meta.exportAs.map(e => literal(e))));
     }
+    if (meta.isStandalone) {
+        definitionMap.set('standalone', literal(true));
+    }
     return definitionMap;
 }
 /**
@@ -18721,16 +18725,16 @@ function addFeatures(definitionMap, meta) {
         if (viewProviders) {
             args.push(viewProviders);
         }
-        features.push(importExpr(Identifiers$1.ProvidersFeature).callFn(args));
+        features.push(importExpr(Identifiers.ProvidersFeature).callFn(args));
     }
     if (meta.usesInheritance) {
-        features.push(importExpr(Identifiers$1.InheritDefinitionFeature));
+        features.push(importExpr(Identifiers.InheritDefinitionFeature));
     }
     if (meta.fullInheritance) {
-        features.push(importExpr(Identifiers$1.CopyDefinitionFeature));
+        features.push(importExpr(Identifiers.CopyDefinitionFeature));
     }
     if (meta.lifecycle.usesOnChanges) {
-        features.push(importExpr(Identifiers$1.NgOnChangesFeature));
+        features.push(importExpr(Identifiers.NgOnChangesFeature));
     }
     if (features.length) {
         definitionMap.set('features', literalArr(features));
@@ -18742,7 +18746,7 @@ function addFeatures(definitionMap, meta) {
 function compileDirectiveFromMetadata(meta, constantPool, bindingParser) {
     const definitionMap = baseDirectiveFields(meta, constantPool, bindingParser);
     addFeatures(definitionMap, meta);
-    const expression = importExpr(Identifiers$1.defineDirective).callFn([definitionMap.toLiteralMap()], undefined, true);
+    const expression = importExpr(Identifiers.defineDirective).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createDirectiveType(meta);
     return { expression, type, statements: [] };
 }
@@ -18768,7 +18772,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     const templateName = templateTypeName ? `${templateTypeName}_Template` : null;
     const changeDetection = meta.changeDetection;
     const template = meta.template;
-    const templateBuilder = new TemplateDefinitionBuilder(constantPool, BindingScope.createRootScope(), 0, templateTypeName, null, null, templateName, Identifiers$1.namespaceHTML, meta.relativeContextFilePath, meta.i18nUseExternalIds);
+    const templateBuilder = new TemplateDefinitionBuilder(constantPool, BindingScope.createRootScope(), 0, templateTypeName, null, null, templateName, Identifiers.namespaceHTML, meta.relativeContextFilePath, meta.i18nUseExternalIds);
     const templateFunctionExpression = templateBuilder.buildTemplateFunction(template.nodes, []);
     // We need to provide this so that dynamically generated components know what
     // projected content blocks to pass through to the component when it is instantiated.
@@ -18834,7 +18838,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     if (changeDetection != null && changeDetection !== ChangeDetectionStrategy.Default) {
         definitionMap.set('changeDetection', literal(changeDetection));
     }
-    const expression = importExpr(Identifiers$1.defineComponent).callFn([definitionMap.toLiteralMap()], undefined, true);
+    const expression = importExpr(Identifiers.defineComponent).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createComponentType(meta);
     return { expression, type, statements: [] };
 }
@@ -18845,7 +18849,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
 function createComponentType(meta) {
     const typeParams = createDirectiveTypeParams(meta);
     typeParams.push(stringArrayAsType(meta.template.ngContentSelectors));
-    return expressionType(importExpr(Identifiers$1.ComponentDeclaration, typeParams));
+    return expressionType(importExpr(Identifiers.ComponentDeclaration, typeParams));
 }
 /**
  * Compiles the array literal of declarations into an expression according to the provided emit
@@ -18861,7 +18865,7 @@ function compileDeclarationList(list, mode) {
             return fn([], [new ReturnStatement(list)]);
         case 2 /* ClosureResolved */:
             // directives: function () { return [MyDir].map(ng.resolveForwardRef); }
-            const resolvedList = list.prop('map').callFn([importExpr(Identifiers$1.resolveForwardRef)]);
+            const resolvedList = list.prop('map').callFn([importExpr(Identifiers.resolveForwardRef)]);
             return fn([], [new ReturnStatement(resolvedList)]);
     }
 }
@@ -18896,13 +18900,13 @@ function createContentQueriesFunction(queries, constantPool, name) {
     const tempAllocator = temporaryAllocator(updateStatements, TEMPORARY_NAME);
     for (const query of queries) {
         // creation, e.g. r3.contentQuery(dirIndex, somePredicate, true, null);
-        createStatements.push(importExpr(Identifiers$1.contentQuery)
+        createStatements.push(importExpr(Identifiers.contentQuery)
             .callFn([variable('dirIndex'), ...prepareQueryParams(query, constantPool)])
             .toStmt());
         // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
         const temporary = tempAllocator();
-        const getQueryList = importExpr(Identifiers$1.loadQuery).callFn([]);
-        const refresh = importExpr(Identifiers$1.queryRefresh).callFn([temporary.set(getQueryList)]);
+        const getQueryList = importExpr(Identifiers.loadQuery).callFn([]);
+        const refresh = importExpr(Identifiers.queryRefresh).callFn([temporary.set(getQueryList)]);
         const updateDirective = variable(CONTEXT_NAME)
             .prop(query.propertyName)
             .set(query.first ? temporary.prop('first') : temporary);
@@ -18954,7 +18958,7 @@ function createDirectiveTypeParams(meta) {
  */
 function createDirectiveType(meta) {
     const typeParams = createDirectiveTypeParams(meta);
-    return expressionType(importExpr(Identifiers$1.DirectiveDeclaration, typeParams));
+    return expressionType(importExpr(Identifiers.DirectiveDeclaration, typeParams));
 }
 // Define and update any view queries
 function createViewQueriesFunction(viewQueries, constantPool, name) {
@@ -18963,12 +18967,12 @@ function createViewQueriesFunction(viewQueries, constantPool, name) {
     const tempAllocator = temporaryAllocator(updateStatements, TEMPORARY_NAME);
     viewQueries.forEach((query) => {
         // creation, e.g. r3.viewQuery(somePredicate, true);
-        const queryDefinition = importExpr(Identifiers$1.viewQuery).callFn(prepareQueryParams(query, constantPool));
+        const queryDefinition = importExpr(Identifiers.viewQuery).callFn(prepareQueryParams(query, constantPool));
         createStatements.push(queryDefinition.toStmt());
         // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
         const temporary = tempAllocator();
-        const getQueryList = importExpr(Identifiers$1.loadQuery).callFn([]);
-        const refresh = importExpr(Identifiers$1.queryRefresh).callFn([temporary.set(getQueryList)]);
+        const getQueryList = importExpr(Identifiers.loadQuery).callFn([]);
+        const refresh = importExpr(Identifiers.queryRefresh).callFn([temporary.set(getQueryList)]);
         const updateDirective = variable(CONTEXT_NAME)
             .prop(query.propertyName)
             .set(query.first ? temporary.prop('first') : temporary);
@@ -18991,14 +18995,14 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     if (classAttr !== undefined) {
         styleBuilder.registerClassAttr(classAttr);
     }
-    const createStatements = [];
-    const updateStatements = [];
+    const createInstructions = [];
+    const updateInstructions = [];
+    const updateVariables = [];
     const hostBindingSourceSpan = typeSourceSpan;
     // Calculate host event bindings
     const eventBindings = bindingParser.createDirectiveHostEventAsts(hostBindingsMetadata.listeners, hostBindingSourceSpan);
     if (eventBindings && eventBindings.length) {
-        const listeners = createHostListeners(eventBindings, name);
-        createStatements.push(...listeners);
+        createInstructions.push(...createHostListeners(eventBindings, name));
     }
     // Calculate the host property bindings
     const bindings = bindingParser.createBoundHostProperties(hostBindingsMetadata.properties, hostBindingSourceSpan);
@@ -19034,7 +19038,7 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     const propertyBindings = [];
     const attributeBindings = [];
     const syntheticHostBindings = [];
-    allOtherBindings.forEach((binding) => {
+    for (const binding of allOtherBindings) {
         // resolve literal arrays and literal objects
         const value = binding.expression.visit(getValueConverter());
         const bindingExpr = bindingFn(bindingContext, value);
@@ -19050,7 +19054,7 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
                 // of different security contexts. In this case we use special sanitization function and
                 // select the actual sanitizer at runtime based on a tag name that is provided while
                 // invoking sanitization function.
-                sanitizerFn = importExpr(Identifiers$1.sanitizeUrlOrResourceUrl);
+                sanitizerFn = importExpr(Identifiers.sanitizeUrlOrResourceUrl);
             }
             else {
                 sanitizerFn = resolveSanitizationFn(securityContexts[0], isAttribute);
@@ -19060,28 +19064,28 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
         if (sanitizerFn) {
             instructionParams.push(sanitizerFn);
         }
-        updateStatements.push(...bindingExpr.stmts);
-        if (instruction === Identifiers$1.hostProperty) {
+        updateVariables.push(...bindingExpr.stmts);
+        if (instruction === Identifiers.hostProperty) {
             propertyBindings.push(instructionParams);
         }
-        else if (instruction === Identifiers$1.attribute) {
+        else if (instruction === Identifiers.attribute) {
             attributeBindings.push(instructionParams);
         }
-        else if (instruction === Identifiers$1.syntheticHostProperty) {
+        else if (instruction === Identifiers.syntheticHostProperty) {
             syntheticHostBindings.push(instructionParams);
         }
         else {
-            updateStatements.push(importExpr(instruction).callFn(instructionParams).toStmt());
+            updateInstructions.push({ reference: instruction, paramsOrFn: instructionParams, span: null });
         }
-    });
-    if (propertyBindings.length > 0) {
-        updateStatements.push(chainedInstruction(Identifiers$1.hostProperty, propertyBindings).toStmt());
     }
-    if (attributeBindings.length > 0) {
-        updateStatements.push(chainedInstruction(Identifiers$1.attribute, attributeBindings).toStmt());
+    for (const bindingParams of propertyBindings) {
+        updateInstructions.push({ reference: Identifiers.hostProperty, paramsOrFn: bindingParams, span: null });
     }
-    if (syntheticHostBindings.length > 0) {
-        updateStatements.push(chainedInstruction(Identifiers$1.syntheticHostProperty, syntheticHostBindings).toStmt());
+    for (const bindingParams of attributeBindings) {
+        updateInstructions.push({ reference: Identifiers.attribute, paramsOrFn: bindingParams, span: null });
+    }
+    for (const bindingParams of syntheticHostBindings) {
+        updateInstructions.push({ reference: Identifiers.syntheticHostProperty, paramsOrFn: bindingParams, span: null });
     }
     // since we're dealing with directives/components and both have hostBinding
     // functions, we need to generate a special hostAttrs instruction that deals
@@ -19097,37 +19101,37 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
         // the update block of a component/directive templateFn/hostBindingsFn so that the bindings
         // are evaluated and updated for the element.
         styleBuilder.buildUpdateLevelInstructions(getValueConverter()).forEach(instruction => {
-            if (instruction.calls.length > 0) {
-                const calls = [];
-                instruction.calls.forEach(call => {
-                    // we subtract a value of `1` here because the binding slot was already allocated
-                    // at the top of this method when all the input bindings were counted.
-                    totalHostVarsCount +=
-                        Math.max(call.allocateBindingSlots - MIN_STYLING_BINDING_SLOTS_REQUIRED, 0);
-                    calls.push(convertStylingCall(call, bindingContext, bindingFn));
+            for (const call of instruction.calls) {
+                // we subtract a value of `1` here because the binding slot was already allocated
+                // at the top of this method when all the input bindings were counted.
+                totalHostVarsCount +=
+                    Math.max(call.allocateBindingSlots - MIN_STYLING_BINDING_SLOTS_REQUIRED, 0);
+                updateInstructions.push({
+                    reference: instruction.reference,
+                    paramsOrFn: convertStylingCall(call, bindingContext, bindingFn),
+                    span: null
                 });
-                updateStatements.push(chainedInstruction(instruction.reference, calls).toStmt());
             }
         });
     }
     if (totalHostVarsCount) {
         definitionMap.set('hostVars', literal(totalHostVarsCount));
     }
-    if (createStatements.length > 0 || updateStatements.length > 0) {
+    if (createInstructions.length > 0 || updateInstructions.length > 0) {
         const hostBindingsFnName = name ? `${name}_HostBindings` : null;
         const statements = [];
-        if (createStatements.length > 0) {
-            statements.push(renderFlagCheckIfStmt(1 /* Create */, createStatements));
+        if (createInstructions.length > 0) {
+            statements.push(renderFlagCheckIfStmt(1 /* Create */, getInstructionStatements(createInstructions)));
         }
-        if (updateStatements.length > 0) {
-            statements.push(renderFlagCheckIfStmt(2 /* Update */, updateStatements));
+        if (updateInstructions.length > 0) {
+            statements.push(renderFlagCheckIfStmt(2 /* Update */, updateVariables.concat(getInstructionStatements(updateInstructions))));
         }
         return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], statements, INFERRED_TYPE, null, hostBindingsFnName);
     }
     return null;
 }
 function bindingFn(implicit, value) {
-    return convertPropertyBinding(null, implicit, value, 'b', () => error('Unexpected interpolation'));
+    return convertPropertyBinding(null, implicit, value, 'b');
 }
 function convertStylingCall(call, bindingContext, bindingFn) {
     return call.params(value => bindingFn(bindingContext, value).currValExpr);
@@ -19139,7 +19143,7 @@ function getBindingNameAndInstruction(binding) {
     const attrMatches = bindingName.match(ATTR_REGEX);
     if (attrMatches) {
         bindingName = attrMatches[1];
-        instruction = Identifiers$1.attribute;
+        instruction = Identifiers.attribute;
     }
     else {
         if (binding.isAnimation) {
@@ -19147,19 +19151,19 @@ function getBindingNameAndInstruction(binding) {
             // host bindings that have a synthetic property (e.g. @foo) should always be rendered
             // in the context of the component and not the parent. Therefore there is a special
             // compatibility instruction available for this purpose.
-            instruction = Identifiers$1.syntheticHostProperty;
+            instruction = Identifiers.syntheticHostProperty;
         }
         else {
-            instruction = Identifiers$1.hostProperty;
+            instruction = Identifiers.hostProperty;
         }
     }
     return { bindingName, instruction, isAttribute: !!attrMatches };
 }
 function createHostListeners(eventBindings, name) {
-    const listeners = [];
-    const syntheticListeners = [];
+    const listenerParams = [];
+    const syntheticListenerParams = [];
     const instructions = [];
-    eventBindings.forEach(binding => {
+    for (const binding of eventBindings) {
         let bindingName = binding.name && sanitizeIdentifier(binding.name);
         const bindingFnName = binding.type === 1 /* Animation */ ?
             prepareSyntheticListenerFunctionName(bindingName, binding.targetOrPhase) :
@@ -19167,17 +19171,17 @@ function createHostListeners(eventBindings, name) {
         const handlerName = name && bindingName ? `${name}_${bindingFnName}_HostBindingHandler` : null;
         const params = prepareEventListenerParameters(BoundEvent.fromParsedEvent(binding), handlerName);
         if (binding.type == 1 /* Animation */) {
-            syntheticListeners.push(params);
+            syntheticListenerParams.push(params);
         }
         else {
-            listeners.push(params);
+            listenerParams.push(params);
         }
-    });
-    if (syntheticListeners.length > 0) {
-        instructions.push(chainedInstruction(Identifiers$1.syntheticHostListener, syntheticListeners).toStmt());
     }
-    if (listeners.length > 0) {
-        instructions.push(chainedInstruction(Identifiers$1.listener, listeners).toStmt());
+    for (const params of syntheticListenerParams) {
+        instructions.push({ reference: Identifiers.syntheticHostListener, paramsOrFn: params, span: null });
+    }
+    for (const params of listenerParams) {
+        instructions.push({ reference: Identifiers.listener, paramsOrFn: params, span: null });
     }
     return instructions;
 }
@@ -19298,6 +19302,7 @@ class CompilerFacadeImpl {
             deps: null,
             pipeName: facade.pipeName,
             pure: facade.pure,
+            isStandalone: facade.isStandalone,
         };
         const res = compilePipeFromMetadata(metadata);
         return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
@@ -19366,7 +19371,7 @@ class CompilerFacadeImpl {
             declarations: facade.declarations.map(wrapReference),
             imports: facade.imports.map(wrapReference),
             exports: facade.exports.map(wrapReference),
-            emitInline: true,
+            selectorScopeMode: R3SelectorScopeMode.Inline,
             containsForwardDecls: false,
             schemas: facade.schemas ? facade.schemas.map(wrapReference) : null,
             id: facade.id ? new WrappedNodeExpr(facade.id) : null,
@@ -19508,7 +19513,7 @@ function convertDirectiveFacadeToMetadata(facade) {
     return Object.assign(Object.assign({}, facade), { typeArgumentCount: 0, typeSourceSpan: facade.typeSourceSpan, type: wrapReference(facade.type), internalType: new WrappedNodeExpr(facade.type), deps: null, host: extractHostBindings(facade.propMetadata, facade.typeSourceSpan, facade.host), inputs: Object.assign(Object.assign({}, inputsFromMetadata), inputsFromType), outputs: Object.assign(Object.assign({}, outputsFromMetadata), outputsFromType), queries: facade.queries.map(convertToR3QueryMetadata), providers: facade.providers != null ? new WrappedNodeExpr(facade.providers) : null, viewQueries: facade.viewQueries.map(convertToR3QueryMetadata), fullInheritance: false });
 }
 function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
@@ -19528,6 +19533,7 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         deps: null,
         typeArgumentCount: 0,
         fullInheritance: false,
+        isStandalone: (_j = declaration.isStandalone) !== null && _j !== void 0 ? _j : false,
     };
 }
 function convertHostDeclarationToMetadata(host = {}) {
@@ -19691,7 +19697,7 @@ function parseInputOutputs(values) {
     }, {});
 }
 function convertDeclarePipeFacadeToMetadata(declaration) {
-    var _a;
+    var _a, _b;
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
@@ -19700,6 +19706,7 @@ function convertDeclarePipeFacadeToMetadata(declaration) {
         pipeName: declaration.name,
         deps: null,
         pure: (_a = declaration.pure) !== null && _a !== void 0 ? _a : true,
+        isStandalone: (_b = declaration.isStandalone) !== null && _b !== void 0 ? _b : false,
     };
 }
 function convertDeclareInjectorFacadeToMetadata(declaration) {
@@ -19726,7 +19733,7 @@ function publishFacade(global) {
  * 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
  */
-const VERSION = new Version('14.0.0-next.0');
+const VERSION = new Version('14.0.0-next.11');
 
 /**
  * @license
@@ -21725,7 +21732,7 @@ function compileClassMetadata(metadata) {
     var _a, _b;
     // Generate an ngDevMode guarded call to setClassMetadata with the class identifier and its
     // metadata.
-    const fnCall = importExpr(Identifiers$1.setClassMetadata).callFn([
+    const fnCall = importExpr(Identifiers.setClassMetadata).callFn([
         metadata.type,
         metadata.decorators,
         (_a = metadata.ctorParameters) !== null && _a !== void 0 ? _a : literal(null),
@@ -21753,13 +21760,13 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('14.0.0-next.0'));
-    definitionMap.set('ngImport', importExpr(Identifiers$1.core));
+    definitionMap.set('version', literal('14.0.0-next.11'));
+    definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
     definitionMap.set('ctorParameters', metadata.ctorParameters);
     definitionMap.set('propDecorators', metadata.propDecorators);
-    return importExpr(Identifiers$1.declareClassMetadata).callFn([definitionMap.toLiteralMap()]);
+    return importExpr(Identifiers.declareClassMetadata).callFn([definitionMap.toLiteralMap()]);
 }
 
 /**
@@ -21859,7 +21866,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$5 = '12.0.0';
  */
 function compileDeclareDirectiveFromMetadata(meta) {
     const definitionMap = createDirectiveDefinitionMap(meta);
-    const expression = importExpr(Identifiers$1.declareDirective).callFn([definitionMap.toLiteralMap()]);
+    const expression = importExpr(Identifiers.declareDirective).callFn([definitionMap.toLiteralMap()]);
     const type = createDirectiveType(meta);
     return { expression, type, statements: [] };
 }
@@ -21870,7 +21877,7 @@ function compileDeclareDirectiveFromMetadata(meta) {
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('14.0.0-next.0'));
+    definitionMap.set('version', literal('14.0.0-next.11'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.internalType);
     // e.g. `selector: 'some-dir'`
@@ -21896,7 +21903,7 @@ function createDirectiveDefinitionMap(meta) {
     if (meta.lifecycle.usesOnChanges) {
         definitionMap.set('usesOnChanges', literal(true));
     }
-    definitionMap.set('ngImport', importExpr(Identifiers$1.core));
+    definitionMap.set('ngImport', importExpr(Identifiers.core));
     return definitionMap;
 }
 /**
@@ -21963,7 +21970,7 @@ function compileHostMetadata(meta) {
  */
 function compileDeclareComponentFromMetadata(meta, template, additionalTemplateInfo) {
     const definitionMap = createComponentDefinitionMap(meta, template, additionalTemplateInfo);
-    const expression = importExpr(Identifiers$1.declareComponent).callFn([definitionMap.toLiteralMap()]);
+    const expression = importExpr(Identifiers.declareComponent).callFn([definitionMap.toLiteralMap()]);
     const type = createComponentType(meta);
     return { expression, type, statements: [] };
 }
@@ -21983,11 +21990,11 @@ function createComponentDefinitionMap(meta, template, templateInfo) {
     definitionMap.set('viewProviders', meta.viewProviders);
     definitionMap.set('animations', meta.animations);
     if (meta.changeDetection !== undefined) {
-        definitionMap.set('changeDetection', importExpr(Identifiers$1.ChangeDetectionStrategy)
+        definitionMap.set('changeDetection', importExpr(Identifiers.ChangeDetectionStrategy)
             .prop(ChangeDetectionStrategy[meta.changeDetection]));
     }
     if (meta.encapsulation !== ViewEncapsulation.Emulated) {
-        definitionMap.set('encapsulation', importExpr(Identifiers$1.ViewEncapsulation).prop(ViewEncapsulation[meta.encapsulation]));
+        definitionMap.set('encapsulation', importExpr(Identifiers.ViewEncapsulation).prop(ViewEncapsulation[meta.encapsulation]));
     }
     if (meta.interpolation !== DEFAULT_INTERPOLATION_CONFIG) {
         definitionMap.set('interpolation', literalArr([literal(meta.interpolation.start), literal(meta.interpolation.end)]));
@@ -22091,13 +22098,13 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('14.0.0-next.0'));
-    definitionMap.set('ngImport', importExpr(Identifiers$1.core));
+    definitionMap.set('version', literal('14.0.0-next.11'));
+    definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('deps', compileDependencies(meta.deps));
-    definitionMap.set('target', importExpr(Identifiers$1.FactoryTarget).prop(FactoryTarget$1[meta.target]));
+    definitionMap.set('target', importExpr(Identifiers.FactoryTarget).prop(FactoryTarget$1[meta.target]));
     return {
-        expression: importExpr(Identifiers$1.declareFactory).callFn([definitionMap.toLiteralMap()]),
+        expression: importExpr(Identifiers.declareFactory).callFn([definitionMap.toLiteralMap()]),
         statements: [],
         type: createFactoryType(meta),
     };
@@ -22123,7 +22130,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$3 = '12.0.0';
  */
 function compileDeclareInjectableFromMetadata(meta) {
     const definitionMap = createInjectableDefinitionMap(meta);
-    const expression = importExpr(Identifiers$1.declareInjectable).callFn([definitionMap.toLiteralMap()]);
+    const expression = importExpr(Identifiers.declareInjectable).callFn([definitionMap.toLiteralMap()]);
     const type = createInjectableType(meta);
     return { expression, type, statements: [] };
 }
@@ -22133,8 +22140,8 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('14.0.0-next.0'));
-    definitionMap.set('ngImport', importExpr(Identifiers$1.core));
+    definitionMap.set('version', literal('14.0.0-next.11'));
+    definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // Only generate providedIn property if it has a non-null value
     if (meta.providedIn !== undefined) {
@@ -22181,7 +22188,7 @@ function createInjectableDefinitionMap(meta) {
 const MINIMUM_PARTIAL_LINKER_VERSION$2 = '12.0.0';
 function compileDeclareInjectorFromMetadata(meta) {
     const definitionMap = createInjectorDefinitionMap(meta);
-    const expression = importExpr(Identifiers$1.declareInjector).callFn([definitionMap.toLiteralMap()]);
+    const expression = importExpr(Identifiers.declareInjector).callFn([definitionMap.toLiteralMap()]);
     const type = createInjectorType(meta);
     return { expression, type, statements: [] };
 }
@@ -22191,8 +22198,8 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('14.0.0-next.0'));
-    definitionMap.set('ngImport', importExpr(Identifiers$1.core));
+    definitionMap.set('version', literal('14.0.0-next.11'));
+    definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     definitionMap.set('providers', meta.providers);
     if (meta.imports.length > 0) {
@@ -22218,7 +22225,7 @@ function createInjectorDefinitionMap(meta) {
 const MINIMUM_PARTIAL_LINKER_VERSION$1 = '12.0.0';
 function compileDeclareNgModuleFromMetadata(meta) {
     const definitionMap = createNgModuleDefinitionMap(meta);
-    const expression = importExpr(Identifiers$1.declareNgModule).callFn([definitionMap.toLiteralMap()]);
+    const expression = importExpr(Identifiers.declareNgModule).callFn([definitionMap.toLiteralMap()]);
     const type = createNgModuleType(meta);
     return { expression, type, statements: [] };
 }
@@ -22228,8 +22235,8 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('14.0.0-next.0'));
-    definitionMap.set('ngImport', importExpr(Identifiers$1.core));
+    definitionMap.set('version', literal('14.0.0-next.11'));
+    definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.internalType);
     // We only generate the keys in the metadata if the arrays contain values.
     // We must wrap the arrays inside a function if any of the values are a forward reference to a
@@ -22276,7 +22283,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION = '12.0.0';
  */
 function compileDeclarePipeFromMetadata(meta) {
     const definitionMap = createPipeDefinitionMap(meta);
-    const expression = importExpr(Identifiers$1.declarePipe).callFn([definitionMap.toLiteralMap()]);
+    const expression = importExpr(Identifiers.declarePipe).callFn([definitionMap.toLiteralMap()]);
     const type = createPipeType(meta);
     return { expression, type, statements: [] };
 }
@@ -22286,8 +22293,8 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('14.0.0-next.0'));
-    definitionMap.set('ngImport', importExpr(Identifiers$1.core));
+    definitionMap.set('version', literal('14.0.0-next.11'));
+    definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.internalType);
     // e.g. `name: "myPipe"`
@@ -22336,5 +22343,5 @@ publishFacade(_global);
  * found in the LICENSE file at https://angular.io/license
  */
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, Identifiers, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, Quote, R3BoundTarget, Identifiers$1 as R3Identifiers, R3TargetBinder, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3SelectorScopeMode, R3TargetBinder, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map