@angular-eslint/bundled-angular-compiler 15.2.2-alpha.9 → 16.0.0-alpha.1

package/dist/index.js

@@ -1,5 +1,7 @@
+'use strict';
+
 /**
- * @license Angular v15.2.5
+ * @license Angular v16.0.0-rc.2
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -740,7 +742,7 @@ class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
  *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
  */
 function sha1(str) {
-    textEncoder !== null && textEncoder !== void 0 ? textEncoder : (textEncoder = new TextEncoder());
+    textEncoder ??= new TextEncoder();
     const utf8 = [...textEncoder.encode(str)];
     const words32 = bytesToWords32(utf8, Endian.Big);
     const len = utf8.length * 8;
@@ -806,7 +808,7 @@ function fk(index, b, c, d) {
  * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
  */
 function fingerprint(str) {
-    textEncoder !== null && textEncoder !== void 0 ? textEncoder : (textEncoder = new TextEncoder());
+    textEncoder ??= new TextEncoder();
     const utf8 = textEncoder.encode(str);
     const view = new DataView(utf8.buffer, utf8.byteOffset, utf8.byteLength);
     let hi = hash32(view, utf8.length, 0);
@@ -1381,7 +1383,6 @@ class TemplateLiteral {
 }
 class TemplateLiteralElement {
     constructor(text, sourceSpan, rawText) {
-        var _a;
         this.text = text;
         this.sourceSpan = sourceSpan;
         // If `rawText` is not provided, try to extract the raw string from its
@@ -1391,7 +1392,7 @@ class TemplateLiteralElement {
         // - "`" and "${" are template string control sequences that would otherwise prematurely
         // indicate the end of the template literal element.
         this.rawText =
-            (_a = rawText !== null && rawText !== void 0 ? rawText : sourceSpan === null || sourceSpan === void 0 ? void 0 : sourceSpan.toString()) !== null && _a !== void 0 ? _a : escapeForTemplateLiteral(escapeSlashes(text));
+            rawText ?? sourceSpan?.toString() ?? escapeForTemplateLiteral(escapeSlashes(text));
     }
 }
 class LiteralPiece {
@@ -1461,12 +1462,11 @@ class LocalizedString extends Expression {
         return createCookedRawString(metaBlock, this.messageParts[0].text, this.getMessagePartSourceSpan(0));
     }
     getMessagePartSourceSpan(i) {
-        var _a, _b;
-        return (_b = (_a = this.messageParts[i]) === null || _a === void 0 ? void 0 : _a.sourceSpan) !== null && _b !== void 0 ? _b : this.sourceSpan;
+        return this.messageParts[i]?.sourceSpan ?? this.sourceSpan;
     }
     getPlaceholderSourceSpan(i) {
-        var _a, _b, _c, _d;
-        return (_d = (_b = (_a = this.placeHolderNames[i]) === null || _a === void 0 ? void 0 : _a.sourceSpan) !== null && _b !== void 0 ? _b : (_c = this.expressions[i]) === null || _c === void 0 ? void 0 : _c.sourceSpan) !== null && _d !== void 0 ? _d : this.sourceSpan;
+        return this.placeHolderNames[i]?.sourceSpan ?? this.expressions[i]?.sourceSpan ??
+            this.sourceSpan;
     }
     /**
      * Serialize the given `placeholderName` and `messagePart` into "cooked" and "raw" strings that
@@ -1480,11 +1480,10 @@ class LocalizedString extends Expression {
      * @param partIndex The index of the message part to serialize.
      */
     serializeI18nTemplatePart(partIndex) {
-        var _a;
         const placeholder = this.placeHolderNames[partIndex - 1];
         const messagePart = this.messageParts[partIndex];
         let metaBlock = placeholder.text;
-        if (((_a = placeholder.associatedMessage) === null || _a === void 0 ? void 0 : _a.legacyIds.length) === 0) {
+        if (placeholder.associatedMessage?.legacyIds.length === 0) {
             metaBlock += `${ID_SEPARATOR$1}${computeMsgId(placeholder.associatedMessage.messageString, placeholder.associatedMessage.meaning)}`;
         }
         return createCookedRawString(metaBlock, messagePart.text, this.getMessagePartSourceSpan(partIndex));
@@ -1787,8 +1786,7 @@ class Statement {
         return (this.modifiers & modifier) !== 0;
     }
     addLeadingComment(leadingComment) {
-        var _a;
-        this.leadingComments = (_a = this.leadingComments) !== null && _a !== void 0 ? _a : [];
+        this.leadingComments = this.leadingComments ?? [];
         this.leadingComments.push(leadingComment);
     }
 }
@@ -2224,6 +2222,7 @@ class FixupExpression extends Expression {
     constructor(resolved) {
         super(resolved.type);
         this.resolved = resolved;
+        this.shared = false;
         this.original = resolved;
     }
     visitExpression(visitor, context) {
@@ -2431,209 +2430,209 @@ function isLongStringLiteral(expr) {
 
 const CORE = '@angular/core';
 class Identifiers {
+    /* Methods */
+    static { this.NEW_METHOD = 'factory'; }
+    static { this.TRANSFORM_METHOD = 'transform'; }
+    static { this.PATCH_DEPS = 'patchedDeps'; }
+    static { this.core = { name: null, moduleName: CORE }; }
+    /* Instructions */
+    static { this.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE }; }
+    static { this.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE }; }
+    static { this.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE }; }
+    static { this.element = { name: 'ɵɵelement', moduleName: CORE }; }
+    static { this.elementStart = { name: 'ɵɵelementStart', moduleName: CORE }; }
+    static { this.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE }; }
+    static { this.advance = { name: 'ɵɵadvance', moduleName: CORE }; }
+    static { this.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE }; }
+    static { this.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE }; }
+    static { this.attribute = { name: 'ɵɵattribute', moduleName: CORE }; }
+    static { this.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE }; }
+    static { this.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE }; }
+    static { this.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE }; }
+    static { this.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE }; }
+    static { this.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE }; }
+    static { this.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE }; }
+    static { this.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE }; }
+    static { this.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE }; }
+    static { this.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE }; }
+    static { this.classProp = { name: 'ɵɵclassProp', moduleName: CORE }; }
+    static { this.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE }; }
+    static { this.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE }; }
+    static { this.elementContainer = { name: 'ɵɵelementContainer', moduleName: CORE }; }
+    static { this.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE }; }
+    static { this.styleMapInterpolate1 = { name: 'ɵɵstyleMapInterpolate1', moduleName: CORE }; }
+    static { this.styleMapInterpolate2 = { name: 'ɵɵstyleMapInterpolate2', moduleName: CORE }; }
+    static { this.styleMapInterpolate3 = { name: 'ɵɵstyleMapInterpolate3', moduleName: CORE }; }
+    static { this.styleMapInterpolate4 = { name: 'ɵɵstyleMapInterpolate4', moduleName: CORE }; }
+    static { this.styleMapInterpolate5 = { name: 'ɵɵstyleMapInterpolate5', moduleName: CORE }; }
+    static { this.styleMapInterpolate6 = { name: 'ɵɵstyleMapInterpolate6', moduleName: CORE }; }
+    static { this.styleMapInterpolate7 = { name: 'ɵɵstyleMapInterpolate7', moduleName: CORE }; }
+    static { this.styleMapInterpolate8 = { name: 'ɵɵstyleMapInterpolate8', moduleName: CORE }; }
+    static { this.styleMapInterpolateV = { name: 'ɵɵstyleMapInterpolateV', moduleName: CORE }; }
+    static { this.classMap = { name: 'ɵɵclassMap', moduleName: CORE }; }
+    static { this.classMapInterpolate1 = { name: 'ɵɵclassMapInterpolate1', moduleName: CORE }; }
+    static { this.classMapInterpolate2 = { name: 'ɵɵclassMapInterpolate2', moduleName: CORE }; }
+    static { this.classMapInterpolate3 = { name: 'ɵɵclassMapInterpolate3', moduleName: CORE }; }
+    static { this.classMapInterpolate4 = { name: 'ɵɵclassMapInterpolate4', moduleName: CORE }; }
+    static { this.classMapInterpolate5 = { name: 'ɵɵclassMapInterpolate5', moduleName: CORE }; }
+    static { this.classMapInterpolate6 = { name: 'ɵɵclassMapInterpolate6', moduleName: CORE }; }
+    static { this.classMapInterpolate7 = { name: 'ɵɵclassMapInterpolate7', moduleName: CORE }; }
+    static { this.classMapInterpolate8 = { name: 'ɵɵclassMapInterpolate8', moduleName: CORE }; }
+    static { this.classMapInterpolateV = { name: 'ɵɵclassMapInterpolateV', moduleName: CORE }; }
+    static { this.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE }; }
+    static { this.stylePropInterpolate1 = { name: 'ɵɵstylePropInterpolate1', moduleName: CORE }; }
+    static { this.stylePropInterpolate2 = { name: 'ɵɵstylePropInterpolate2', moduleName: CORE }; }
+    static { this.stylePropInterpolate3 = { name: 'ɵɵstylePropInterpolate3', moduleName: CORE }; }
+    static { this.stylePropInterpolate4 = { name: 'ɵɵstylePropInterpolate4', moduleName: CORE }; }
+    static { this.stylePropInterpolate5 = { name: 'ɵɵstylePropInterpolate5', moduleName: CORE }; }
+    static { this.stylePropInterpolate6 = { name: 'ɵɵstylePropInterpolate6', moduleName: CORE }; }
+    static { this.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE }; }
+    static { this.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE }; }
+    static { this.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE }; }
+    static { this.nextContext = { name: 'ɵɵnextContext', moduleName: CORE }; }
+    static { this.resetView = { name: 'ɵɵresetView', moduleName: CORE }; }
+    static { this.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE }; }
+    static { this.text = { name: 'ɵɵtext', moduleName: CORE }; }
+    static { this.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE }; }
+    static { this.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE }; }
+    static { this.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE }; }
+    static { this.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE }; }
+    static { this.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE }; }
+    static { this.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE }; }
+    static { this.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE }; }
+    static { this.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE }; }
+    static { this.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE }; }
+    static { this.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE }; }
+    static { this.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE }; }
+    static { this.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE }; }
+    static { this.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE }; }
+    static { this.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE }; }
+    static { this.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE }; }
+    static { this.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE }; }
+    static { this.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE }; }
+    static { this.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE }; }
+    static { this.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE }; }
+    static { this.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE }; }
+    static { this.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE }; }
+    static { this.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE }; }
+    static { this.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE }; }
+    static { this.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE }; }
+    static { this.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE }; }
+    static { this.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE }; }
+    static { this.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE }; }
+    static { this.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE }; }
+    static { this.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE }; }
+    static { this.hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE }; }
+    static { this.property = { name: 'ɵɵproperty', moduleName: CORE }; }
+    static { this.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE }; }
+    static { this.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE }; }
+    static { this.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE }; }
+    static { this.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE }; }
+    static { this.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE }; }
+    static { this.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE }; }
+    static { this.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE }; }
+    static { this.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE }; }
+    static { this.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE }; }
+    static { this.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE }; }
+    static { this.i18n = { name: 'ɵɵi18n', moduleName: CORE }; }
+    static { this.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE }; }
+    static { this.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE }; }
+    static { this.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE }; }
+    static { this.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE }; }
+    static { this.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE }; }
+    static { this.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE }; }
+    static { this.pipe = { name: 'ɵɵpipe', moduleName: CORE }; }
+    static { this.projection = { name: 'ɵɵprojection', moduleName: CORE }; }
+    static { this.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE }; }
+    static { this.reference = { name: 'ɵɵreference', moduleName: CORE }; }
+    static { this.inject = { name: 'ɵɵinject', moduleName: CORE }; }
+    static { this.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE }; }
+    static { this.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE }; }
+    static { this.invalidFactory = { name: 'ɵɵinvalidFactory', moduleName: CORE }; }
+    static { this.invalidFactoryDep = { name: 'ɵɵinvalidFactoryDep', moduleName: CORE }; }
+    static { this.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE }; }
+    static { this.forwardRef = { name: 'forwardRef', moduleName: CORE }; }
+    static { this.resolveForwardRef = { name: 'resolveForwardRef', moduleName: CORE }; }
+    static { this.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE }; }
+    static { this.declareInjectable = { name: 'ɵɵngDeclareInjectable', moduleName: CORE }; }
+    static { this.InjectableDeclaration = { name: 'ɵɵInjectableDeclaration', moduleName: CORE }; }
+    static { this.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE }; }
+    static { this.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE }; }
+    static { this.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE }; }
+    static { this.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE }; }
+    static { this.declareComponent = { name: 'ɵɵngDeclareComponent', moduleName: CORE }; }
+    static { this.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE }; }
+    static { this.ChangeDetectionStrategy = {
+        name: 'ChangeDetectionStrategy',
+        moduleName: CORE,
+    }; }
+    static { this.ViewEncapsulation = {
+        name: 'ViewEncapsulation',
+        moduleName: CORE,
+    }; }
+    static { this.ComponentDeclaration = {
+        name: 'ɵɵComponentDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.FactoryDeclaration = {
+        name: 'ɵɵFactoryDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.declareFactory = { name: 'ɵɵngDeclareFactory', moduleName: CORE }; }
+    static { this.FactoryTarget = { name: 'ɵɵFactoryTarget', moduleName: CORE }; }
+    static { this.defineDirective = { name: 'ɵɵdefineDirective', moduleName: CORE }; }
+    static { this.declareDirective = { name: 'ɵɵngDeclareDirective', moduleName: CORE }; }
+    static { this.DirectiveDeclaration = {
+        name: 'ɵɵDirectiveDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.InjectorDef = { name: 'ɵɵInjectorDef', moduleName: CORE }; }
+    static { this.InjectorDeclaration = { name: 'ɵɵInjectorDeclaration', moduleName: CORE }; }
+    static { this.defineInjector = { name: 'ɵɵdefineInjector', moduleName: CORE }; }
+    static { this.declareInjector = { name: 'ɵɵngDeclareInjector', moduleName: CORE }; }
+    static { this.NgModuleDeclaration = {
+        name: 'ɵɵNgModuleDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.ModuleWithProviders = {
+        name: 'ModuleWithProviders',
+        moduleName: CORE,
+    }; }
+    static { this.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE }; }
+    static { this.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE }; }
+    static { this.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE }; }
+    static { this.registerNgModuleType = { name: 'ɵɵregisterNgModuleType', moduleName: CORE }; }
+    static { this.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE }; }
+    static { this.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE }; }
+    static { this.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE }; }
+    static { this.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE }; }
+    static { this.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE }; }
+    static { this.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE }; }
+    static { this.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE }; }
+    static { this.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE }; }
+    static { this.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE }; }
+    static { this.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE }; }
+    static { this.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE }; }
+    static { this.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE }; }
+    static { this.StandaloneFeature = { name: 'ɵɵStandaloneFeature', moduleName: CORE }; }
+    static { this.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE }; }
+    static { this.HostDirectivesFeature = { name: 'ɵɵHostDirectivesFeature', moduleName: CORE }; }
+    static { this.listener = { name: 'ɵɵlistener', moduleName: CORE }; }
+    static { this.getInheritedFactory = {
+        name: 'ɵɵgetInheritedFactory',
+        moduleName: CORE,
+    }; }
+    // sanitization-related functions
+    static { this.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE }; }
+    static { this.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE }; }
+    static { this.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE }; }
+    static { this.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE }; }
+    static { this.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE }; }
+    static { this.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE }; }
+    static { this.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE }; }
+    static { this.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE }; }
+    static { this.validateIframeAttribute = { name: 'ɵɵvalidateIframeAttribute', moduleName: CORE }; }
 }
-/* Methods */
-Identifiers.NEW_METHOD = 'factory';
-Identifiers.TRANSFORM_METHOD = 'transform';
-Identifiers.PATCH_DEPS = 'patchedDeps';
-Identifiers.core = { name: null, moduleName: CORE };
-/* Instructions */
-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,
-};
-Identifiers.ViewEncapsulation = {
-    name: 'ViewEncapsulation',
-    moduleName: CORE,
-};
-Identifiers.ComponentDeclaration = {
-    name: 'ɵɵComponentDeclaration',
-    moduleName: CORE,
-};
-Identifiers.FactoryDeclaration = {
-    name: 'ɵɵFactoryDeclaration',
-    moduleName: CORE,
-};
-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,
-};
-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,
-};
-Identifiers.ModuleWithProviders = {
-    name: 'ModuleWithProviders',
-    moduleName: CORE,
-};
-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.StandaloneFeature = { name: 'ɵɵStandaloneFeature', moduleName: CORE };
-Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE };
-Identifiers.HostDirectivesFeature = { name: 'ɵɵHostDirectivesFeature', moduleName: CORE };
-Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE };
-Identifiers.getInheritedFactory = {
-    name: 'ɵɵgetInheritedFactory',
-    moduleName: CORE,
-};
-// sanitization-related functions
-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 };
-Identifiers.validateIframeAttribute = { name: 'ɵɵvalidateIframeAttribute', moduleName: CORE };
 
 const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
 function dashCaseToCamelCase(input) {
@@ -3493,7 +3492,7 @@ function compileFactoryFunction(meta) {
     // delegated factory (which is used to create the current type) then this is only the type-to-
     // create parameter (t).
     const typeForCtor = !isDelegatedFactoryMetadata(meta) ?
-        new BinaryOperatorExpr(exports.BinaryOperator.Or, t, meta.internalType) :
+        new BinaryOperatorExpr(exports.BinaryOperator.Or, t, meta.type.value) :
         t;
     let ctorExpr = null;
     if (meta.deps !== null) {
@@ -3540,7 +3539,7 @@ function compileFactoryFunction(meta) {
     }
     else if (baseFactoryVar !== null) {
         // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
-        const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]);
+        const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.type.value]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
         const baseFactory = new BinaryOperatorExpr(exports.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
         body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));
@@ -3907,9 +3906,9 @@ class Message {
         this.meaning = meaning;
         this.description = description;
         this.customId = customId;
-        this.id = this.customId;
         /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
         this.legacyIds = [];
+        this.id = this.customId;
         this.messageString = serializeMessage(this.nodes);
         if (nodes.length) {
             this.sources = [{
@@ -3945,11 +3944,12 @@ class Container {
     }
 }
 class Icu {
-    constructor(expression, type, cases, sourceSpan) {
+    constructor(expression, type, cases, sourceSpan, expressionPlaceholder) {
         this.expression = expression;
         this.type = type;
         this.cases = cases;
         this.sourceSpan = sourceSpan;
+        this.expressionPlaceholder = expressionPlaceholder;
     }
     visit(visitor, context) {
         return visitor.visitIcu(this, context);
@@ -4005,8 +4005,7 @@ class CloneVisitor {
     visitIcu(icu, context) {
         const cases = {};
         Object.keys(icu.cases).forEach(key => cases[key] = icu.cases[key].visit(this, context));
-        const msg = new Icu(icu.expression, icu.type, cases, icu.sourceSpan);
-        msg.expressionPlaceholder = icu.expressionPlaceholder;
+        const msg = new Icu(icu.expression, icu.type, cases, icu.sourceSpan, icu.expressionPlaceholder);
         return msg;
     }
     visitTagPlaceholder(ph, context) {
@@ -4620,30 +4619,30 @@ function asLiteral(value) {
     }
     return literal(value, INFERRED_TYPE);
 }
-function conditionallyCreateMapObjectLiteral(keys, keepDeclared) {
-    if (Object.getOwnPropertyNames(keys).length > 0) {
-        return mapToExpression(keys, keepDeclared);
+function conditionallyCreateDirectiveBindingLiteral(map, keepDeclared) {
+    const keys = Object.getOwnPropertyNames(map);
+    if (keys.length === 0) {
+        return null;
     }
-    return null;
-}
-function mapToExpression(map, keepDeclared) {
-    return literalMap(Object.getOwnPropertyNames(map).map(key => {
-        // canonical syntax: `dirProp: publicProp`
+    return literalMap(keys.map(key => {
         const value = map[key];
         let declaredName;
         let publicName;
         let minifiedName;
         let needsDeclaredName;
-        if (Array.isArray(value)) {
-            [publicName, declaredName] = value;
+        if (typeof value === 'string') {
+            // canonical syntax: `dirProp: publicProp`
+            declaredName = key;
             minifiedName = key;
-            needsDeclaredName = publicName !== declaredName;
-        }
-        else {
-            minifiedName = declaredName = key;
             publicName = value;
             needsDeclaredName = false;
         }
+        else {
+            minifiedName = key;
+            declaredName = value.classPropertyName;
+            publicName = value.bindingPropertyName;
+            needsDeclaredName = publicName !== declaredName;
+        }
         return {
             key: minifiedName,
             // put quotes around keys that contain potentially unsafe characters
@@ -4725,7 +4724,9 @@ function getAttrsForDirectiveMatching(elOrTpl) {
             }
         });
         elOrTpl.inputs.forEach(i => {
-            attributesMap[i.name] = '';
+            if (i.type === 0 /* BindingType.Property */) {
+                attributesMap[i.name] = '';
+            }
         });
         elOrTpl.outputs.forEach(o => {
             attributesMap[o.name] = '';
@@ -4755,13 +4756,13 @@ function getInterpolationArgsLength(interpolation) {
  * 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;
     let chainLength = 0;
     for (const current of instructions) {
-        const resolvedParams = (_a = (typeof current.paramsOrFn === 'function' ? current.paramsOrFn() : current.paramsOrFn)) !== null && _a !== void 0 ? _a : [];
+        const resolvedParams = (typeof current.paramsOrFn === 'function' ? current.paramsOrFn() : current.paramsOrFn) ??
+            [];
         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.
@@ -4793,7 +4794,6 @@ function compileInjectable(meta, resolveForwardRefs) {
     const factoryMeta = {
         name: meta.name,
         type: meta.type,
-        internalType: meta.internalType,
         typeArgumentCount: meta.typeArgumentCount,
         deps: [],
         target: exports.FactoryTarget.Injectable,
@@ -4805,14 +4805,19 @@ function compileInjectable(meta, resolveForwardRefs) {
         //
         // A special case exists for useClass: Type where Type is the injectable type itself and no
         // deps are specified, in which case 'useClass' is effectively ignored.
-        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.internalType);
+        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.type.value);
         let deps = undefined;
         if (meta.deps !== undefined) {
             deps = meta.deps;
         }
         if (deps !== undefined) {
             // factory: () => new meta.useClass(...deps)
-            result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useClass.expression, delegateDeps: deps, delegateType: R3FactoryDelegateType.Class }));
+            result = compileFactoryFunction({
+                ...factoryMeta,
+                delegate: meta.useClass.expression,
+                delegateDeps: deps,
+                delegateType: R3FactoryDelegateType.Class,
+            });
         }
         else if (useClassOnSelf) {
             result = compileFactoryFunction(factoryMeta);
@@ -4826,7 +4831,12 @@ function compileInjectable(meta, resolveForwardRefs) {
     }
     else if (meta.useFactory !== undefined) {
         if (meta.deps !== undefined) {
-            result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useFactory, delegateDeps: meta.deps || [], delegateType: R3FactoryDelegateType.Function }));
+            result = compileFactoryFunction({
+                ...factoryMeta,
+                delegate: meta.useFactory,
+                delegateDeps: meta.deps || [],
+                delegateType: R3FactoryDelegateType.Function,
+            });
         }
         else {
             result = {
@@ -4839,19 +4849,25 @@ function compileInjectable(meta, resolveForwardRefs) {
         // Note: it's safe to use `meta.useValue` instead of the `USE_VALUE in meta` check used for
         // client code because meta.useValue is an Expression which will be defined even if the actual
         // value is undefined.
-        result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: meta.useValue.expression }));
+        result = compileFactoryFunction({
+            ...factoryMeta,
+            expression: meta.useValue.expression,
+        });
     }
     else if (meta.useExisting !== undefined) {
         // useExisting is an `inject` call on the existing token.
-        result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: importExpr(Identifiers.inject).callFn([meta.useExisting.expression]) }));
+        result = compileFactoryFunction({
+            ...factoryMeta,
+            expression: importExpr(Identifiers.inject).callFn([meta.useExisting.expression]),
+        });
     }
     else {
         result = {
             statements: [],
-            expression: delegateToFactory(meta.type.value, meta.internalType, resolveForwardRefs)
+            expression: delegateToFactory(meta.type.value, meta.type.value, resolveForwardRefs)
         };
     }
-    const token = meta.internalType;
+    const token = meta.type.value;
     const injectableProps = new DefinitionMap();
     injectableProps.set('token', token);
     injectableProps.set('factory', result.expression);
@@ -4870,28 +4886,28 @@ function compileInjectable(meta, resolveForwardRefs) {
 function createInjectableType(meta) {
     return new ExpressionType(importExpr(Identifiers.InjectableDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount)]));
 }
-function delegateToFactory(type, internalType, unwrapForwardRefs) {
-    if (type.node === internalType.node) {
+function delegateToFactory(type, useType, unwrapForwardRefs) {
+    if (type.node === useType.node) {
         // The types are the same, so we can simply delegate directly to the type's factory.
         // ```
         // factory: type.ɵfac
         // ```
-        return internalType.prop('ɵfac');
+        return useType.prop('ɵfac');
     }
     if (!unwrapForwardRefs) {
         // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that
         // accepts a sub-type as an argument.
         // ```
-        // factory: function(t) { return internalType.ɵfac(t); }
+        // factory: function(t) { return useType.ɵfac(t); }
         // ```
-        return createFactoryFunction(internalType);
+        return createFactoryFunction(useType);
     }
-    // The internalType is actually wrapped in a `forwardRef()` so we need to resolve that before
+    // The useType is actually wrapped in a `forwardRef()` so we need to resolve that before
     // calling its factory.
     // ```
     // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); }
     // ```
-    const unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([internalType]);
+    const unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([useType]);
     return createFactoryFunction(unwrappedType);
 }
 function createFactoryFunction(type) {
@@ -5299,45 +5315,6 @@ class AbstractJsEmitterVisitor extends AbstractEmitterVisitor {
         this.visitAllObjects(param => ctx.print(null, param.name), params, ctx, ',');
     }
 }
-
-/**
- * @fileoverview
- * A module to facilitate use of a Trusted Types policy within the JIT
- * compiler. It lazily constructs the Trusted Types policy, providing helper
- * utilities for promoting strings to Trusted Types. When Trusted Types are not
- * available, strings are used as a fallback.
- * @security All use of this module is security-sensitive and should go through
- * security review.
- */
-/**
- * The Trusted Types policy, or null if Trusted Types are not
- * enabled/supported, or undefined if the policy has not been created yet.
- */
-let policy;
-/**
- * Returns the Trusted Types policy, or null if Trusted Types are not
- * enabled/supported. The first call to this function will create the policy.
- */
-function getPolicy() {
-    if (policy === undefined) {
-        policy = null;
-        if (_global.trustedTypes) {
-            try {
-                policy =
-                    _global.trustedTypes.createPolicy('angular#unsafe-jit', {
-                        createScript: (s) => s,
-                    });
-            }
-            catch (_a) {
-                // trustedTypes.createPolicy throws if called with a name that is
-                // already registered, even in report-only mode. Until the API changes,
-                // catch the error not to break the applications functionally. In such
-                // cases, the code will fall back to using strings.
-            }
-        }
-    }
-    return policy;
-}
 /**
  * Unsafely promote a string to a TrustedScript, falling back to strings when
  * Trusted Types are not available.
@@ -5346,8 +5323,7 @@ function getPolicy() {
  * interpreted and executed as a script by a browser, e.g. when calling eval.
  */
 function trustedScriptFromString(script) {
-    var _a;
-    return ((_a = getPolicy()) === null || _a === void 0 ? void 0 : _a.createScript(script)) || script;
+    return script;
 }
 /**
  * Unsafely call the Function constructor with the given string arguments.
@@ -5593,10 +5569,10 @@ exports.R3SelectorScopeMode = void 0;
  * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`.
  */
 function compileNgModule(meta) {
-    const { adjacentType, internalType, bootstrap, declarations, imports, exports: exports$1, schemas, containsForwardDecls, selectorScopeMode, id } = meta;
+    const { type: moduleType, bootstrap, declarations, imports, exports: exports$1, schemas, containsForwardDecls, selectorScopeMode, id } = meta;
     const statements = [];
     const definitionMap = new DefinitionMap();
-    definitionMap.set('type', internalType);
+    definitionMap.set('type', moduleType.value);
     if (bootstrap.length > 0) {
         definitionMap.set('bootstrap', refsToArray(bootstrap, containsForwardDecls));
     }
@@ -5631,7 +5607,7 @@ function compileNgModule(meta) {
         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());
+        statements.push(importExpr(Identifiers.registerNgModuleType).callFn([moduleType.value, id]).toStmt());
     }
     const expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createNgModuleType(meta);
@@ -5680,7 +5656,7 @@ function createNgModuleType({ type: moduleType, declarations, exports, imports,
  * symbols to become tree-shakeable.
  */
 function generateSetNgModuleScopeCall(meta) {
-    const { adjacentType: moduleType, declarations, imports, exports, containsForwardDecls } = meta;
+    const { type: moduleType, declarations, imports, exports, containsForwardDecls } = meta;
     const scopeMap = new DefinitionMap();
     if (declarations.length > 0) {
         scopeMap.set('declarations', refsToArray(declarations, containsForwardDecls));
@@ -5697,7 +5673,7 @@ function generateSetNgModuleScopeCall(meta) {
     // setNgModuleScope(...)
     const fnCall = new InvokeFunctionExpr(
     /* fn */ importExpr(Identifiers.setNgModuleScope), 
-    /* args */ [moduleType, scopeMap.toLiteralMap()]);
+    /* args */ [moduleType.value, scopeMap.toLiteralMap()]);
     // (ngJitMode guard) && setNgModuleScope(...)
     const guardedCall = jitOnlyGuardedExpression(fnCall);
     // function() { (ngJitMode guard) && setNgModuleScope(...); }
@@ -5805,8 +5781,7 @@ class ImplicitReceiver extends AST {
  */
 class ThisReceiver extends ImplicitReceiver {
     visit(visitor, context = null) {
-        var _a;
-        return (_a = visitor.visitThisReceiver) === null || _a === void 0 ? void 0 : _a.call(visitor, this, context);
+        return visitor.visitThisReceiver?.(this, context);
     }
 }
 /**
@@ -6476,8 +6451,8 @@ class BoundElementProperty {
 }
 
 class EventHandlerVars {
+    static { this.event = variable('$event'); }
 }
-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).
@@ -6798,8 +6773,7 @@ class _AstToIrVisitor {
         return convertToStatementIfNeeded(mode, literal(ast.value, type, this.convertSourceSpan(ast.span)));
     }
     _getLocal(name, receiver) {
-        var _a;
-        if (((_a = this._localResolver.globals) === null || _a === void 0 ? void 0 : _a.has(name)) && receiver instanceof ThisReceiver) {
+        if (this._localResolver.globals?.has(name) && receiver instanceof ThisReceiver) {
             return null;
         }
         return this._localResolver.getLocal(name);
@@ -7547,10 +7521,13 @@ class ShadowCss {
      * @returns the css rule modified with the scoped keyframes name.
      */
     _scopeLocalKeyframeDeclarations(rule, scopeSelector, unscopedKeyframesSet) {
-        return Object.assign(Object.assign({}, rule), { selector: rule.selector.replace(/(^@(?:-webkit-)?keyframes(?:\s+))(['"]?)(.+)\2(\s*)$/, (_, start, quote, keyframeName, endSpaces) => {
+        return {
+            ...rule,
+            selector: rule.selector.replace(/(^@(?:-webkit-)?keyframes(?:\s+))(['"]?)(.+)\2(\s*)$/, (_, start, quote, keyframeName, endSpaces) => {
                 unscopedKeyframesSet.add(unescapeQuotes(keyframeName, quote));
                 return `${start}${quote}${scopeSelector}_${keyframeName}${quote}${endSpaces}`;
-            }) });
+            }),
+        };
     }
     /**
      * Function used to scope a keyframes name (obtained from an animation declaration)
@@ -7598,7 +7575,7 @@ class ShadowCss {
         content = content.replace(/((?:^|\s+|;)(?:-webkit-)?animation-name(?:\s*):(?:\s*))([^;]+)/g, (_match, start, commaSeparatedKeyframes) => `${start}${commaSeparatedKeyframes.split(',')
             .map((keyframe) => this._scopeAnimationKeyframe(keyframe, scopeSelector, unscopedKeyframesSet))
             .join(',')}`);
-        return Object.assign(Object.assign({}, rule), { content });
+        return { ...rule, content };
     }
     /*
      * Process styles to convert native ShadowDOM rules that will trip
@@ -7729,7 +7706,6 @@ class ShadowCss {
      */
     _convertColonHostContext(cssText) {
         return cssText.replace(_cssColonHostContextReGlobal, selectorText => {
-            var _a;
             // We have captured a selector that contains a `:host-context` rule.
             // For backward compatibility `:host-context` may contain a comma separated list of selectors.
             // Each context selector group will contain a list of host-context selectors that must match
@@ -7744,7 +7720,7 @@ class ShadowCss {
             while (match = _cssColonHostContextRe.exec(selectorText)) {
                 // `match` = [':host-context(<selectors>)<rest>', <selectors>, <rest>]
                 // The `<selectors>` could actually be a comma separated list: `:host-context(.one, .two)`.
-                const newContextSelectors = ((_a = match[1]) !== null && _a !== void 0 ? _a : '').trim().split(',').map(m => m.trim()).filter(m => m !== '');
+                const newContextSelectors = (match[1] ?? '').trim().split(',').map(m => m.trim()).filter(m => m !== '');
                 // We must duplicate the current selector group for each of these new selectors.
                 // For example if the current groups are:
                 // ```
@@ -7881,7 +7857,6 @@ class ShadowCss {
     // return a selector with [name] suffix on each simple selector
     // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]  /** @internal */
     _applySelectorScope(selector, scopeSelector, hostSelector) {
-        var _a;
         const isRe = /\[is=([^\]]*)\]/g;
         scopeSelector = scopeSelector.replace(isRe, (_, ...parts) => parts[0]);
         const attrName = '[' + scopeSelector + ']';
@@ -7932,7 +7907,7 @@ class ShadowCss {
             // (ie: ".\fc ber" for ".über") is not a separator between 2 selectors
             // also keep in mind that backslashes are replaced by a placeholder by SafeSelector
             // These escaped selectors happen for example when esbuild runs with optimization.minify.
-            if (part.match(_placeholderRe) && ((_a = selector[res.index + 1]) === null || _a === void 0 ? void 0 : _a.match(/[a-fA-F\d]/))) {
+            if (part.match(_placeholderRe) && selector[res.index + 1]?.match(/[a-fA-F\d]/)) {
                 continue;
             }
             shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
@@ -8294,6 +8269,470 @@ function repeatGroups(groups, multiples) {
     }
 }
 
+exports.TagContentType = void 0;
+(function (TagContentType) {
+    TagContentType[TagContentType["RAW_TEXT"] = 0] = "RAW_TEXT";
+    TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
+    TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
+})(exports.TagContentType || (exports.TagContentType = {}));
+function splitNsName(elementName) {
+    if (elementName[0] != ':') {
+        return [null, elementName];
+    }
+    const colonIndex = elementName.indexOf(':', 1);
+    if (colonIndex === -1) {
+        throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+    }
+    return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
+}
+// `<ng-container>` tags work the same regardless the namespace
+function isNgContainer(tagName) {
+    return splitNsName(tagName)[1] === 'ng-container';
+}
+// `<ng-content>` tags work the same regardless the namespace
+function isNgContent(tagName) {
+    return splitNsName(tagName)[1] === 'ng-content';
+}
+// `<ng-template>` tags work the same regardless the namespace
+function isNgTemplate(tagName) {
+    return splitNsName(tagName)[1] === 'ng-template';
+}
+function getNsPrefix(fullName) {
+    return fullName === null ? null : splitNsName(fullName)[0];
+}
+function mergeNsAndName(prefix, localName) {
+    return prefix ? `:${prefix}:${localName}` : localName;
+}
+
+/**
+ * Enumeration of the types of attributes which can be applied to an element.
+ */
+var ElementAttributeKind;
+(function (ElementAttributeKind) {
+    /**
+     * Static attributes.
+     */
+    ElementAttributeKind[ElementAttributeKind["Attribute"] = 0] = "Attribute";
+    /**
+     * Class bindings.
+     */
+    ElementAttributeKind[ElementAttributeKind["Class"] = 1] = "Class";
+    /**
+     * Style bindings.
+     */
+    ElementAttributeKind[ElementAttributeKind["Style"] = 2] = "Style";
+    /**
+     * Dynamic property or attribute bindings.
+     */
+    ElementAttributeKind[ElementAttributeKind["Binding"] = 3] = "Binding";
+    /**
+     * Attributes on a template node.
+     */
+    ElementAttributeKind[ElementAttributeKind["Template"] = 4] = "Template";
+    /**
+     * Internationalized attributes.
+     */
+    ElementAttributeKind[ElementAttributeKind["I18n"] = 5] = "I18n";
+})(ElementAttributeKind || (ElementAttributeKind = {}));
+
+/**
+ * Distinguishes different kinds of IR operations.
+ *
+ * Includes both creation and update operations.
+ */
+var OpKind;
+(function (OpKind) {
+    /**
+     * A special operation type which is used to represent the beginning and end nodes of a linked
+     * list of operations.
+     */
+    OpKind[OpKind["ListEnd"] = 0] = "ListEnd";
+    /**
+     * An operation which wraps an output AST statement.
+     */
+    OpKind[OpKind["Statement"] = 1] = "Statement";
+    /**
+     * An operation which declares and initializes a `SemanticVariable`.
+     */
+    OpKind[OpKind["Variable"] = 2] = "Variable";
+    /**
+     * An operation to begin rendering of an element.
+     */
+    OpKind[OpKind["ElementStart"] = 3] = "ElementStart";
+    /**
+     * An operation to render an element with no children.
+     */
+    OpKind[OpKind["Element"] = 4] = "Element";
+    /**
+     * An operation which declares an embedded view.
+     */
+    OpKind[OpKind["Template"] = 5] = "Template";
+    /**
+     * An operation to end rendering of an element previously started with `ElementStart`.
+     */
+    OpKind[OpKind["ElementEnd"] = 6] = "ElementEnd";
+    /**
+     * An operation to render a text node.
+     */
+    OpKind[OpKind["Text"] = 7] = "Text";
+    /**
+     * An operation declaring an event listener for an element.
+     */
+    OpKind[OpKind["Listener"] = 8] = "Listener";
+    /**
+     * An operation to interpolate text into a text node.
+     */
+    OpKind[OpKind["InterpolateText"] = 9] = "InterpolateText";
+    /**
+     * An operation to bind an expression to a property of an element.
+     */
+    OpKind[OpKind["Property"] = 10] = "Property";
+    /**
+     * An operation to advance the runtime's implicit slot context during the update phase of a view.
+     */
+    OpKind[OpKind["Advance"] = 11] = "Advance";
+})(OpKind || (OpKind = {}));
+/**
+ * Distinguishes different kinds of IR expressions.
+ */
+var ExpressionKind;
+(function (ExpressionKind) {
+    /**
+     * Read of a variable in a lexical scope.
+     */
+    ExpressionKind[ExpressionKind["LexicalRead"] = 0] = "LexicalRead";
+    /**
+     * A reference to the current view context.
+     */
+    ExpressionKind[ExpressionKind["Context"] = 1] = "Context";
+    /**
+     * Read of a variable declared in a `VariableOp`.
+     */
+    ExpressionKind[ExpressionKind["ReadVariable"] = 2] = "ReadVariable";
+    /**
+     * Runtime operation to navigate to the next view context in the view hierarchy.
+     */
+    ExpressionKind[ExpressionKind["NextContext"] = 3] = "NextContext";
+    /**
+     * Runtime operation to retrieve the value of a local reference.
+     */
+    ExpressionKind[ExpressionKind["Reference"] = 4] = "Reference";
+    /**
+     * Runtime operation to snapshot the current view context.
+     */
+    ExpressionKind[ExpressionKind["GetCurrentView"] = 5] = "GetCurrentView";
+    /**
+     * Runtime operation to restore a snapshotted view.
+     */
+    ExpressionKind[ExpressionKind["RestoreView"] = 6] = "RestoreView";
+    /**
+     * Runtime operation to reset the current view context after `RestoreView`.
+     */
+    ExpressionKind[ExpressionKind["ResetView"] = 7] = "ResetView";
+})(ExpressionKind || (ExpressionKind = {}));
+/**
+ * Distinguishes between different kinds of `SemanticVariable`s.
+ */
+var SemanticVariableKind;
+(function (SemanticVariableKind) {
+    /**
+     * Represents the context of a particular view.
+     */
+    SemanticVariableKind[SemanticVariableKind["Context"] = 0] = "Context";
+    /**
+     * Represents an identifier declared in the lexical scope of a view.
+     */
+    SemanticVariableKind[SemanticVariableKind["Identifier"] = 1] = "Identifier";
+    /**
+     * Represents a saved state that can be used to restore a view in a listener handler function.
+     */
+    SemanticVariableKind[SemanticVariableKind["SavedView"] = 2] = "SavedView";
+})(SemanticVariableKind || (SemanticVariableKind = {}));
+var VisitorContextFlag;
+(function (VisitorContextFlag) {
+    VisitorContextFlag[VisitorContextFlag["None"] = 0] = "None";
+    VisitorContextFlag[VisitorContextFlag["InChildOperation"] = 1] = "InChildOperation";
+})(VisitorContextFlag || (VisitorContextFlag = {}));
+
+/**
+ * A linked list of `Op` nodes of a given subtype.
+ *
+ * @param OpT specific subtype of `Op` nodes which this list contains.
+ */
+class OpList {
+    static { this.nextListId = 0; }
+    constructor() {
+        /**
+         * Debug ID of this `OpList` instance.
+         */
+        this.debugListId = OpList.nextListId++;
+        // OpList uses static head/tail nodes of a special `ListEnd` type.
+        // This avoids the need for special casing of the first and last list
+        // elements in all list operations.
+        this.head = {
+            kind: OpKind.ListEnd,
+            next: null,
+            prev: null,
+            debugListId: this.debugListId,
+        };
+        this.tail = {
+            kind: OpKind.ListEnd,
+            next: null,
+            prev: null,
+            debugListId: this.debugListId,
+        };
+        // Link `head` and `tail` together at the start (list is empty).
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+    /**
+     * Push a new operation to the tail of the list.
+     */
+    push(op) {
+        OpList.assertIsNotEnd(op);
+        OpList.assertIsUnowned(op);
+        op.debugListId = this.debugListId;
+        // The old "previous" node (which might be the head, if the list is empty).
+        const oldLast = this.tail.prev;
+        // Insert `op` following the old last node.
+        op.prev = oldLast;
+        oldLast.next = op;
+        // Connect `op` with the list tail.
+        op.next = this.tail;
+        this.tail.prev = op;
+    }
+    /**
+     * Prepend one or more nodes to the start of the list.
+     */
+    prepend(ops) {
+        if (ops.length === 0) {
+            return;
+        }
+        for (const op of ops) {
+            OpList.assertIsNotEnd(op);
+            OpList.assertIsUnowned(op);
+            op.debugListId = this.debugListId;
+        }
+        const first = this.head.next;
+        let prev = this.head;
+        for (const op of ops) {
+            prev.next = op;
+            op.prev = prev;
+            prev = op;
+        }
+        prev.next = first;
+        first.prev = prev;
+    }
+    /**
+     * `OpList` is iterable via the iteration protocol.
+     *
+     * It's safe to mutate the part of the list that has already been returned by the iterator, up to
+     * and including the last operation returned. Mutations beyond that point _may_ be safe, but may
+     * also corrupt the iteration position and should be avoided.
+     */
+    *[Symbol.iterator]() {
+        let current = this.head.next;
+        while (current !== this.tail) {
+            // Guards against corruption of the iterator state by mutations to the tail of the list during
+            // iteration.
+            OpList.assertIsOwned(current, this.debugListId);
+            const next = current.next;
+            yield current;
+            current = next;
+        }
+    }
+    *reversed() {
+        let current = this.tail.prev;
+        while (current !== this.head) {
+            OpList.assertIsOwned(current, this.debugListId);
+            const prev = current.prev;
+            yield current;
+            current = prev;
+        }
+    }
+    /**
+     * Replace `oldOp` with `newOp` in the list.
+     */
+    static replace(oldOp, newOp) {
+        OpList.assertIsNotEnd(oldOp);
+        OpList.assertIsNotEnd(newOp);
+        OpList.assertIsOwned(oldOp);
+        OpList.assertIsUnowned(newOp);
+        newOp.debugListId = oldOp.debugListId;
+        if (oldOp.prev !== null) {
+            oldOp.prev.next = newOp;
+            newOp.prev = oldOp.prev;
+        }
+        if (oldOp.next !== null) {
+            oldOp.next.prev = newOp;
+            newOp.next = oldOp.next;
+        }
+        oldOp.debugListId = null;
+        oldOp.prev = null;
+        oldOp.next = null;
+    }
+    /**
+     * Replace `oldOp` with some number of new operations in the list (which may include `oldOp`).
+     */
+    static replaceWithMany(oldOp, newOps) {
+        if (newOps.length === 0) {
+            // Replacing with an empty list -> pure removal.
+            OpList.remove(oldOp);
+            return;
+        }
+        OpList.assertIsNotEnd(oldOp);
+        OpList.assertIsOwned(oldOp);
+        const listId = oldOp.debugListId;
+        oldOp.debugListId = null;
+        for (const newOp of newOps) {
+            OpList.assertIsNotEnd(newOp);
+            // `newOp` might be `oldOp`, but at this point it's been marked as unowned.
+            OpList.assertIsUnowned(newOp);
+        }
+        // It should be safe to reuse `oldOp` in the `newOps` list - maybe you want to sandwich an
+        // operation between two new ops.
+        const { prev: oldPrev, next: oldNext } = oldOp;
+        oldOp.prev = null;
+        oldOp.next = null;
+        let prev = oldPrev;
+        for (const newOp of newOps) {
+            this.assertIsUnowned(newOp);
+            newOp.debugListId = listId;
+            prev.next = newOp;
+            newOp.prev = prev;
+            // This _should_ be the case, but set it just in case.
+            newOp.next = null;
+            prev = newOp;
+        }
+        // At the end of iteration, `prev` holds the last node in the list.
+        const first = newOps[0];
+        const last = prev;
+        // Replace `oldOp` with the chain `first` -> `last`.
+        if (oldPrev !== null) {
+            oldPrev.next = first;
+            first.prev = oldOp.prev;
+        }
+        if (oldNext !== null) {
+            oldNext.prev = last;
+            last.next = oldNext;
+        }
+    }
+    /**
+     * Remove the given node from the list which contains it.
+     */
+    static remove(op) {
+        OpList.assertIsNotEnd(op);
+        OpList.assertIsOwned(op);
+        op.prev.next = op.next;
+        op.next.prev = op.prev;
+        // Break any link between the node and this list to safeguard against its usage in future
+        // operations.
+        op.debugListId = null;
+        op.prev = null;
+        op.next = null;
+    }
+    /**
+     * Insert `op` before `before`.
+     */
+    static insertBefore(op, before) {
+        OpList.assertIsNotEnd(before);
+        OpList.assertIsNotEnd(op);
+        OpList.assertIsUnowned(op);
+        OpList.assertIsOwned(before);
+        op.debugListId = before.debugListId;
+        // Just in case.
+        op.prev = null;
+        before.prev.next = op;
+        op.prev = before.prev;
+        op.next = before;
+        before.prev = op;
+    }
+    /**
+     * Asserts that `op` does not currently belong to a list.
+     */
+    static assertIsUnowned(op) {
+        if (op.debugListId !== null) {
+            throw new Error(`AssertionError: illegal operation on owned node: ${OpKind[op.kind]}`);
+        }
+    }
+    /**
+     * Asserts that `op` currently belongs to a list. If `byList` is passed, `op` is asserted to
+     * specifically belong to that list.
+     */
+    static assertIsOwned(op, byList) {
+        if (op.debugListId === null) {
+            throw new Error(`AssertionError: illegal operation on unowned node: ${OpKind[op.kind]}`);
+        }
+        else if (byList !== undefined && op.debugListId !== byList) {
+            throw new Error(`AssertionError: node belongs to the wrong list (expected ${byList}, actual ${op.debugListId})`);
+        }
+    }
+    /**
+     * Asserts that `op` is not a special `ListEnd` node.
+     */
+    static assertIsNotEnd(op) {
+        if (op.kind === OpKind.ListEnd) {
+            throw new Error(`AssertionError: illegal operation on list head or tail`);
+        }
+    }
+}
+/**
+ * `InterpolationConfig` for the `textInterpolate` instruction.
+ */
+({
+    constant: [
+        Identifiers.textInterpolate,
+        Identifiers.textInterpolate1,
+        Identifiers.textInterpolate2,
+        Identifiers.textInterpolate3,
+        Identifiers.textInterpolate4,
+        Identifiers.textInterpolate5,
+        Identifiers.textInterpolate6,
+        Identifiers.textInterpolate7,
+        Identifiers.textInterpolate8,
+    ],
+    variable: Identifiers.textInterpolateV,
+});
+/**
+ * A [fence](https://en.wikipedia.org/wiki/Memory_barrier) flag for an expression which indicates
+ * how that expression can be optimized in relation to other expressions or instructions.
+ *
+ * `Fence`s are a bitfield, so multiple flags may be set on a single expression.
+ */
+var Fence;
+(function (Fence) {
+    /**
+     * Empty flag (no fence exists).
+     */
+    Fence[Fence["None"] = 0] = "None";
+    /**
+     * A context read fence, meaning that the expression in question reads from the "current view"
+     * context of the runtime.
+     */
+    Fence[Fence["ViewContextRead"] = 1] = "ViewContextRead";
+    /**
+     * A context write fence, meaning that the expression in question writes to the "current view"
+     * context of the runtime.
+     *
+     * Note that all `ContextWrite` fences are implicitly `ContextRead` fences as operations which
+     * change the view context do so based on the current one.
+     */
+    Fence[Fence["ViewContextWrite"] = 3] = "ViewContextWrite";
+    /**
+     * Indicates that a call is required for its side-effects, even if nothing reads its result.
+     *
+     * This is also true of `ViewContextWrite` operations **if** they are followed by a
+     * `ViewContextRead`.
+     */
+    Fence[Fence["SideEffectful"] = 4] = "SideEffectful";
+})(Fence || (Fence = {}));
+
+new Set([
+    Identifiers.elementStart,
+    Identifiers.elementEnd,
+    Identifiers.property,
+]);
+
 /**
  * Parses string representation of a style and converts it into object literal.
  *
@@ -9442,7 +9881,6 @@ class Parser$1 {
      *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
      */
     splitInterpolation(input, location, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-        var _a;
         const strings = [];
         const expressions = [];
         const offsets = [];
@@ -9481,7 +9919,7 @@ 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 });
-                const startInOriginalTemplate = (_a = inputToTemplateIndexMap === null || inputToTemplateIndexMap === void 0 ? void 0 : inputToTemplateIndexMap.get(fullStart)) !== null && _a !== void 0 ? _a : fullStart;
+                const startInOriginalTemplate = inputToTemplateIndexMap?.get(fullStart) ?? fullStart;
                 const offset = startInOriginalTemplate + interpStart.length;
                 offsets.push(offset);
                 i = fullEnd;
@@ -10147,8 +10585,7 @@ class _ParseAST {
     parseAccessMember(readReceiver, start, isSafe) {
         const nameStart = this.inputIndex;
         const id = this.withContext(ParseContextFlags.Writable, () => {
-            var _a;
-            const id = (_a = this.expectIdentifierOrKeyword()) !== null && _a !== void 0 ? _a : '';
+            const id = this.expectIdentifierOrKeyword() ?? '';
             if (id.length === 0) {
                 this.error(`Expected identifier for property access`, readReceiver.span.end);
             }
@@ -10654,41 +11091,6 @@ class RecursiveVisitor {
     }
 }
 
-exports.TagContentType = void 0;
-(function (TagContentType) {
-    TagContentType[TagContentType["RAW_TEXT"] = 0] = "RAW_TEXT";
-    TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
-    TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
-})(exports.TagContentType || (exports.TagContentType = {}));
-function splitNsName(elementName) {
-    if (elementName[0] != ':') {
-        return [null, elementName];
-    }
-    const colonIndex = elementName.indexOf(':', 1);
-    if (colonIndex === -1) {
-        throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
-    }
-    return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
-}
-// `<ng-container>` tags work the same regardless the namespace
-function isNgContainer(tagName) {
-    return splitNsName(tagName)[1] === 'ng-container';
-}
-// `<ng-content>` tags work the same regardless the namespace
-function isNgContent(tagName) {
-    return splitNsName(tagName)[1] === 'ng-content';
-}
-// `<ng-template>` tags work the same regardless the namespace
-function isNgTemplate(tagName) {
-    return splitNsName(tagName)[1] === 'ng-template';
-}
-function getNsPrefix(fullName) {
-    return fullName === null ? null : splitNsName(fullName)[0];
-}
-function mergeNsAndName(prefix, localName) {
-    return prefix ? `:${prefix}:${localName}` : localName;
-}
-
 class ElementSchemaRegistry {
 }
 
@@ -11026,8 +11428,7 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
         return ctx ? ctx : SecurityContext.NONE;
     }
     getMappedPropName(propName) {
-        var _a;
-        return (_a = _ATTR_TO_PROP.get(propName)) !== null && _a !== void 0 ? _a : propName;
+        return _ATTR_TO_PROP.get(propName) ?? propName;
     }
     getDefaultComponentElementName() {
         return 'ng-component';
@@ -11060,11 +11461,10 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
     allKnownAttributesOfElement(tagName) {
         const elementProperties = this._schema.get(tagName.toLowerCase()) || this._schema.get('unknown');
         // Convert properties to attributes.
-        return Array.from(elementProperties.keys()).map(prop => { var _a; return (_a = _PROP_TO_ATTR.get(prop)) !== null && _a !== void 0 ? _a : prop; });
+        return Array.from(elementProperties.keys()).map(prop => _PROP_TO_ATTR.get(prop) ?? prop);
     }
     allKnownEventsOfElement(tagName) {
-        var _a;
-        return Array.from((_a = this._eventSchema.get(tagName.toLowerCase())) !== null && _a !== void 0 ? _a : []);
+        return Array.from(this._eventSchema.get(tagName.toLowerCase()) ?? []);
     }
     normalizeAnimationStyleProperty(propName) {
         return dashCaseToCamelCase(propName);
@@ -11136,7 +11536,7 @@ class HtmlTagDefinition {
         this.contentType = contentType;
         this.ignoreFirstLf = ignoreFirstLf;
         this.preventNamespaceInheritance = preventNamespaceInheritance;
-        this.canSelfClose = canSelfClose !== null && canSelfClose !== void 0 ? canSelfClose : isVoid;
+        this.canSelfClose = canSelfClose ?? isVoid;
     }
     isClosedByChild(name) {
         return this.isVoid || name.toLowerCase() in this.closedByChildren;
@@ -11144,7 +11544,7 @@ class HtmlTagDefinition {
     getContentType(prefix) {
         if (typeof this.contentType === 'object') {
             const overrideType = prefix === undefined ? undefined : this.contentType[prefix];
-            return overrideType !== null && overrideType !== void 0 ? overrideType : this.contentType.default;
+            return overrideType ?? this.contentType.default;
         }
         return this.contentType;
     }
@@ -11154,7 +11554,6 @@ let DEFAULT_TAG_DEFINITION;
 // This implementation does not fully conform to the HTML5 spec.
 let TAG_DEFINITIONS;
 function getHtmlTagDefinition(tagName) {
-    var _a, _b;
     if (!TAG_DEFINITIONS) {
         DEFAULT_TAG_DEFINITION = new HtmlTagDefinition({ canSelfClose: true });
         TAG_DEFINITIONS = {
@@ -11228,7 +11627,8 @@ function getHtmlTagDefinition(tagName) {
     }
     // We have to make both a case-sensitive and a case-insensitive lookup, because
     // HTML tag names are case insensitive, whereas some SVG tags are case sensitive.
-    return (_b = (_a = TAG_DEFINITIONS[tagName]) !== null && _a !== void 0 ? _a : TAG_DEFINITIONS[tagName.toLowerCase()]) !== null && _b !== void 0 ? _b : DEFAULT_TAG_DEFINITION;
+    return TAG_DEFINITIONS[tagName] ?? TAG_DEFINITIONS[tagName.toLowerCase()] ??
+        DEFAULT_TAG_DEFINITION;
 }
 
 // Mapping between all HTML entity names and their unicode representation.
@@ -13362,8 +13762,9 @@ const NAMED_ENTITIES = {
     'zwj': '\u200D',
     'zwnj': '\u200C'
 };
-// The &ngsp; pseudo-entity is denoting a space. see:
-// https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart
+// The &ngsp; pseudo-entity is denoting a space.
+// 0xE500 is a PUA (Private Use Areas) unicode character
+// This is inspired by the Angular Dart implementation.
 const NGSP_UNICODE = '\uE500';
 NAMED_ENTITIES['ngsp'] = NGSP_UNICODE;
 
@@ -13524,7 +13925,7 @@ class _Tokenizer {
         const token = {
             type: this._currentTokenType,
             parts,
-            sourceSpan: (end !== null && end !== void 0 ? end : this._cursor).getSpan(this._currentTokenStart, this._leadingTriviaCodePoints),
+            sourceSpan: (end ?? this._cursor).getSpan(this._currentTokenStart, this._leadingTriviaCodePoints),
         };
         this.tokens.push(token);
         this._currentTokenStart = null;
@@ -13646,7 +14047,7 @@ class _Tokenizer {
                 const charCode = parseInt(strNum, isHex ? 16 : 10);
                 this._endToken([String.fromCharCode(charCode), this._cursor.getChars(start)]);
             }
-            catch (_a) {
+            catch {
                 throw this._createError(_unknownEntityErrorMsg(this._cursor.getChars(start)), this._cursor.getSpan());
             }
         }
@@ -14212,7 +14613,7 @@ class EscapedCharacterCursor extends PlainCharacterCursor {
     constructor(fileOrCursor, range) {
         if (fileOrCursor instanceof EscapedCharacterCursor) {
             super(fileOrCursor);
-            this.internalState = Object.assign({}, fileOrCursor.internalState);
+            this.internalState = { ...fileOrCursor.internalState };
         }
         else {
             super(fileOrCursor, range);
@@ -14250,7 +14651,7 @@ class EscapedCharacterCursor extends PlainCharacterCursor {
         if (peek() === $BACKSLASH) {
             // We have hit an escape sequence so we need the internal state to become independent
             // of the external state.
-            this.internalState = Object.assign({}, this.state);
+            this.internalState = { ...this.state };
             // Move past the backslash
             this.advanceState(this.internalState);
             // First check for standard control char sequences
@@ -14766,10 +15167,9 @@ function hasPreserveWhitespacesAttr(attrs) {
     return attrs.some((attr) => attr.name === PRESERVE_WS_ATTR_NAME);
 }
 /**
- * Angular Dart introduced &ngsp; as a placeholder for non-removable space, see:
- * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32
- * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character
- * and later on replaced by a space. We are re-implementing the same idea here.
+ * &ngsp; is a placeholder for non-removable space
+ * &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character
+ * and later on replaced by a space.
  */
 function replaceNgsp(value) {
     // lexer is replacing the &ngsp; pseudo-entity with NGSP_UNICODE
@@ -15612,7 +16012,6 @@ 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;
@@ -15702,7 +16101,7 @@ class HtmlAstToIvyAst {
         }
         // No explicit binding found.
         const keySpan = createKeySpan(srcSpan, '' /* prefix */, name);
-        const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan, (_a = attribute.valueTokens) !== null && _a !== void 0 ? _a : null);
+        const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan, attribute.valueTokens ?? null);
         return hasBinding;
     }
     _visitTextWithInterpolation(value, sourceSpan, interpolatedTokens, i18n) {
@@ -16147,7 +16546,6 @@ class _I18nVisitor {
         return new Message(i18nodes, context.placeholderToContent, context.placeholderToMessage, meaning, description, customId);
     }
     visitElement(el, context) {
-        var _a;
         const children = visitAll(this, el.children, context);
         const attrs = {};
         el.attrs.forEach(attr => {
@@ -16165,7 +16563,7 @@ class _I18nVisitor {
             closePhName = context.placeholderRegistry.getCloseTagPlaceholderName(el.name);
             context.placeholderToContent[closePhName] = {
                 text: `</${el.name}>`,
-                sourceSpan: (_a = el.endSourceSpan) !== null && _a !== void 0 ? _a : el.sourceSpan,
+                sourceSpan: el.endSourceSpan ?? el.sourceSpan,
             };
         }
         const node = new TagPlaceholder(el.name, attrs, startPhName, closePhName, children, isVoid, el.sourceSpan, el.startSourceSpan, el.endSourceSpan);
@@ -16361,12 +16759,11 @@ class I18nMetaVisitor {
         // whether visited nodes contain i18n information
         this.hasI18nMeta = false;
         this._errors = [];
-        // i18n message generation factory
-        this._createI18nMessage = createI18nMessageFactory(this.interpolationConfig);
     }
     _generateI18nMessage(nodes, meta = '', visitNodeFn) {
         const { meaning, description, customId } = this._parseMetadata(meta);
-        const message = this._createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
+        const createI18nMessage = createI18nMessageFactory(this.interpolationConfig);
+        const message = createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
         this._setMessageId(message, meta);
         this._setLegacyIds(message, meta);
         return message;
@@ -16703,11 +17100,10 @@ class LocalizeSerializerVisitor {
         this.pieces.push(new LiteralPiece(serializeIcuNode(icu), icu.sourceSpan));
     }
     visitTagPlaceholder(ph) {
-        var _a, _b;
-        this.pieces.push(this.createPlaceholderPiece(ph.startName, (_a = ph.startSourceSpan) !== null && _a !== void 0 ? _a : ph.sourceSpan));
+        this.pieces.push(this.createPlaceholderPiece(ph.startName, ph.startSourceSpan ?? ph.sourceSpan));
         if (!ph.isVoid) {
             ph.children.forEach(child => child.visit(this));
-            this.pieces.push(this.createPlaceholderPiece(ph.closeName, (_b = ph.endSourceSpan) !== null && _b !== void 0 ? _b : ph.sourceSpan));
+            this.pieces.push(this.createPlaceholderPiece(ph.closeName, ph.endSourceSpan ?? ph.sourceSpan));
         }
     }
     visitPlaceholder(ph) {
@@ -16804,8 +17200,8 @@ function prepareEventListenerParameters(eventAst, handlerName = null, scope = nu
         scope.getOrCreateSharedContextVar(0);
     const bindingStatements = convertActionBinding(scope, implicitReceiverExpr, handler, 'b', eventAst.handlerSpan, implicitReceiverAccesses, EVENT_BINDING_SCOPE_GLOBALS);
     const statements = [];
-    const variableDeclarations = scope === null || scope === void 0 ? void 0 : scope.variableDeclarations();
-    const restoreViewStatement = scope === null || scope === void 0 ? void 0 : scope.restoreViewStatement();
+    const variableDeclarations = scope?.variableDeclarations();
+    const restoreViewStatement = scope?.restoreViewStatement();
     if (variableDeclarations) {
         // `variableDeclarations` needs to run first, because
         // `restoreViewStatement` depends on the result.
@@ -17237,7 +17633,6 @@ class TemplateDefinitionBuilder {
         }
     }
     visitElement(element) {
-        var _a, _b;
         const elementIndex = this.allocateDataSlot();
         const stylingBuilder = new StylingBuilder(null);
         let isNonBindableMode = false;
@@ -17312,7 +17707,7 @@ class TemplateDefinitionBuilder {
                 this.creationInstruction(element.startSourceSpan, Identifiers.disableBindings);
             }
             if (boundI18nAttrs.length > 0) {
-                this.i18nAttributesInstruction(elementIndex, boundI18nAttrs, (_a = element.startSourceSpan) !== null && _a !== void 0 ? _a : element.sourceSpan);
+                this.i18nAttributesInstruction(elementIndex, boundI18nAttrs, element.startSourceSpan ?? element.sourceSpan);
             }
             // Generate Listeners (outputs)
             if (element.outputs.length > 0) {
@@ -17452,7 +17847,7 @@ class TemplateDefinitionBuilder {
         }
         if (!createSelfClosingInstruction) {
             // Finish element construction mode.
-            const span = (_b = element.endSourceSpan) !== null && _b !== void 0 ? _b : element.sourceSpan;
+            const span = element.endSourceSpan ?? element.sourceSpan;
             if (isI18nRootElement) {
                 this.i18nEnd(span, createSelfClosingI18nInstruction);
             }
@@ -17463,7 +17858,6 @@ class TemplateDefinitionBuilder {
         }
     }
     visitTemplate(template) {
-        var _a;
         const NG_TEMPLATE_TAG_NAME = 'ng-template';
         const templateIndex = this.allocateDataSlot();
         if (this.i18n) {
@@ -17516,7 +17910,7 @@ class TemplateDefinitionBuilder {
             // elements, in case of inline templates, corresponding instructions will be generated in the
             // nested template function.
             if (i18nInputs.length > 0) {
-                this.i18nAttributesInstruction(templateIndex, i18nInputs, (_a = template.startSourceSpan) !== null && _a !== void 0 ? _a : template.sourceSpan);
+                this.i18nAttributesInstruction(templateIndex, i18nInputs, template.startSourceSpan ?? template.sourceSpan);
             }
             // Add the input bindings
             if (inputs.length > 0) {
@@ -17577,7 +17971,7 @@ class TemplateDefinitionBuilder {
         // inside ICUs)
         // - all ICU vars (such as `VAR_SELECT` or `VAR_PLURAL`) are replaced with correct values
         const transformFn = (raw) => {
-            const params = Object.assign(Object.assign({}, vars), placeholders);
+            const params = { ...vars, ...placeholders };
             const formatted = formatI18nPlaceholderNamesInMap(params, /* useCamelCase */ false);
             return invokeInstruction(null, Identifiers.i18nPostprocess, [raw, mapLiteral(formatted, true)]);
         };
@@ -18335,7 +18729,7 @@ function parseTemplate(template, templateUrl, options = {}) {
     const { interpolationConfig, preserveWhitespaces, enableI18nLegacyMessageIdFormat } = options;
     const bindingParser = makeBindingParser(interpolationConfig);
     const htmlParser = new HtmlParser();
-    const parseResult = htmlParser.parse(template, templateUrl, Object.assign(Object.assign({ leadingTriviaChars: LEADING_TRIVIA_CHARS }, options), { tokenizeExpansionForms: true }));
+    const parseResult = htmlParser.parse(template, templateUrl, { leadingTriviaChars: LEADING_TRIVIA_CHARS, ...options, tokenizeExpansionForms: true });
     if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors &&
         parseResult.errors.length > 0) {
         const parsedTemplate = {
@@ -18533,7 +18927,7 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     const definitionMap = new DefinitionMap();
     const selectors = parseSelectorToR3Selector(meta.selector);
     // e.g. `type: MyDirective`
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     // e.g. `selectors: [['', 'someDir', '']]`
     if (selectors.length > 0) {
         definitionMap.set('selectors', asLiteral(selectors));
@@ -18548,9 +18942,9 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     // e.g. `hostBindings: (rf, ctx) => { ... }
     definitionMap.set('hostBindings', createHostBindingsFunction(meta.host, meta.typeSourceSpan, bindingParser, constantPool, meta.selector || '', meta.name, definitionMap));
     // e.g 'inputs: {a: 'a'}`
-    definitionMap.set('inputs', conditionallyCreateMapObjectLiteral(meta.inputs, true));
+    definitionMap.set('inputs', conditionallyCreateDirectiveBindingLiteral(meta.inputs, true));
     // e.g 'outputs: {a: 'a'}`
-    definitionMap.set('outputs', conditionallyCreateMapObjectLiteral(meta.outputs));
+    definitionMap.set('outputs', conditionallyCreateDirectiveBindingLiteral(meta.outputs));
     if (meta.exportAs !== null) {
         definitionMap.set('exportAs', literalArr(meta.exportAs.map(e => literal(e))));
     }
@@ -18563,7 +18957,6 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
  * Add features to the definition map.
  */
 function addFeatures(definitionMap, meta) {
-    var _a;
     // e.g. `features: [NgOnChangesFeature]`
     const features = [];
     const providers = meta.providers;
@@ -18588,7 +18981,7 @@ function addFeatures(definitionMap, meta) {
     if (meta.hasOwnProperty('template') && meta.isStandalone) {
         features.push(importExpr(Identifiers.StandaloneFeature));
     }
-    if ((_a = meta.hostDirectives) === null || _a === void 0 ? void 0 : _a.length) {
+    if (meta.hostDirectives?.length) {
         features.push(importExpr(Identifiers.HostDirectivesFeature).callFn([createHostDirectivesFeatureArg(meta.hostDirectives)]));
     }
     if (features.length) {
@@ -18626,34 +19019,43 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     const templateTypeName = meta.name;
     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.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.
-    const ngContentSelectors = templateBuilder.getNgContentSelectors();
-    if (ngContentSelectors) {
-        definitionMap.set('ngContentSelectors', ngContentSelectors);
-    }
-    // e.g. `decls: 2`
-    definitionMap.set('decls', literal(templateBuilder.getConstCount()));
-    // e.g. `vars: 2`
-    definitionMap.set('vars', literal(templateBuilder.getVarCount()));
-    // Generate `consts` section of ComponentDef:
-    // - either as an array:
-    //   `consts: [['one', 'two'], ['three', 'four']]`
-    // - or as a factory function in case additional statements are present (to support i18n):
-    //   `consts: function() { var i18n_0; if (ngI18nClosureMode) {...} else {...} return [i18n_0]; }`
-    const { constExpressions, prepareStatements } = templateBuilder.getConsts();
-    if (constExpressions.length > 0) {
-        let constsExpr = literalArr(constExpressions);
-        // Prepare statements are present - turn `consts` into a function.
-        if (prepareStatements.length > 0) {
-            constsExpr = fn([], [...prepareStatements, new ReturnStatement(constsExpr)]);
-        }
-        definitionMap.set('consts', constsExpr);
-    }
-    definitionMap.set('template', templateFunctionExpression);
+    // Template compilation is currently conditional as we're in the process of rewriting it.
+    {
+        // This is the main path currently used in compilation, which compiles the template with the
+        // legacy `TemplateDefinitionBuilder`.
+        const template = meta.template;
+        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.
+        const ngContentSelectors = templateBuilder.getNgContentSelectors();
+        if (ngContentSelectors) {
+            definitionMap.set('ngContentSelectors', ngContentSelectors);
+        }
+        // e.g. `decls: 2`
+        // definitionMap.set('decls', o.literal(tpl.root.decls!));
+        definitionMap.set('decls', literal(templateBuilder.getConstCount()));
+        // e.g. `vars: 2`
+        // definitionMap.set('vars', o.literal(tpl.root.vars!));
+        definitionMap.set('vars', literal(templateBuilder.getVarCount()));
+        // Generate `consts` section of ComponentDef:
+        // - either as an array:
+        //   `consts: [['one', 'two'], ['three', 'four']]`
+        // - or as a factory function in case additional statements are present (to support i18n):
+        //   `consts: function() { var i18n_0; if (ngI18nClosureMode) {...} else {...} return [i18n_0];
+        //   }`
+        const { constExpressions, prepareStatements } = templateBuilder.getConsts();
+        if (constExpressions.length > 0) {
+            let constsExpr = literalArr(constExpressions);
+            // Prepare statements are present - turn `consts` into a function.
+            if (prepareStatements.length > 0) {
+                constsExpr = fn([], [...prepareStatements, new ReturnStatement(constsExpr)]);
+            }
+            definitionMap.set('consts', constsExpr);
+        }
+        definitionMap.set('template', templateFunctionExpression);
+    }
     if (meta.declarations.length > 0) {
         definitionMap.set('dependencies', compileDeclarationList(literalArr(meta.declarations.map(decl => decl.type)), meta.declarationListEmitMode));
     }
@@ -18802,11 +19204,24 @@ function createBaseDirectiveTypeParams(meta) {
         typeWithParameters(meta.type.type, meta.typeArgumentCount),
         selectorForType !== null ? stringAsType(selectorForType) : NONE_TYPE,
         meta.exportAs !== null ? stringArrayAsType(meta.exportAs) : NONE_TYPE,
-        expressionType(stringMapAsLiteralExpression(meta.inputs)),
+        expressionType(getInputsTypeExpression(meta)),
         expressionType(stringMapAsLiteralExpression(meta.outputs)),
         stringArrayAsType(meta.queries.map(q => q.propertyName)),
     ];
 }
+function getInputsTypeExpression(meta) {
+    return literalMap(Object.keys(meta.inputs).map(key => {
+        const value = meta.inputs[key];
+        return {
+            key,
+            value: literalMap([
+                { key: 'alias', value: literal(value.bindingPropertyName), quoted: true },
+                { key: 'required', value: literal(value.required), quoted: true }
+            ]),
+            quoted: true
+        };
+    }));
+}
 /**
  * Creates the type specification from the directive meta. This type is inserted into .d.ts files
  * to be consumed by upstream compilations.
@@ -19136,8 +19551,7 @@ function compileStyles(styles, selector, hostSelector) {
     });
 }
 function createHostDirectivesType(meta) {
-    var _a;
-    if (!((_a = meta.hostDirectives) === null || _a === void 0 ? void 0 : _a.length)) {
+    if (!meta.hostDirectives?.length) {
         return NONE_TYPE;
     }
     return expressionType(literalArr(meta.hostDirectives.map(hostMeta => literalMap([
@@ -19220,7 +19634,6 @@ class CompilerFacadeImpl {
         const metadata = {
             name: facade.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: 0,
             deps: null,
             pipeName: facade.pipeName,
@@ -19236,35 +19649,31 @@ class CompilerFacadeImpl {
         return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []);
     }
     compileInjectable(angularCoreEnv, sourceMapUrl, facade) {
-        var _a;
         const { expression, statements } = compileInjectable({
             name: facade.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: facade.typeArgumentCount,
             providedIn: computeProvidedIn(facade.providedIn),
             useClass: convertToProviderExpression(facade, 'useClass'),
             useFactory: wrapExpression(facade, 'useFactory'),
             useValue: convertToProviderExpression(facade, 'useValue'),
             useExisting: convertToProviderExpression(facade, 'useExisting'),
-            deps: (_a = facade.deps) === null || _a === void 0 ? void 0 : _a.map(convertR3DependencyMetadata),
+            deps: facade.deps?.map(convertR3DependencyMetadata),
         }, 
         /* resolveForwardRefs */ true);
         return this.jitExpression(expression, angularCoreEnv, sourceMapUrl, statements);
     }
     compileInjectableDeclaration(angularCoreEnv, sourceMapUrl, facade) {
-        var _a;
         const { expression, statements } = compileInjectable({
             name: facade.type.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: 0,
             providedIn: computeProvidedIn(facade.providedIn),
             useClass: convertToProviderExpression(facade, 'useClass'),
             useFactory: wrapExpression(facade, 'useFactory'),
             useValue: convertToProviderExpression(facade, 'useValue'),
             useExisting: convertToProviderExpression(facade, 'useExisting'),
-            deps: (_a = facade.deps) === null || _a === void 0 ? void 0 : _a.map(convertR3DeclareDependencyMetadata),
+            deps: facade.deps?.map(convertR3DeclareDependencyMetadata),
         }, 
         /* resolveForwardRefs */ true);
         return this.jitExpression(expression, angularCoreEnv, sourceMapUrl, statements);
@@ -19273,7 +19682,6 @@ class CompilerFacadeImpl {
         const meta = {
             name: facade.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             providers: facade.providers && facade.providers.length > 0 ?
                 new WrappedNodeExpr(facade.providers) :
                 null,
@@ -19290,8 +19698,6 @@ class CompilerFacadeImpl {
     compileNgModule(angularCoreEnv, sourceMapUrl, facade) {
         const meta = {
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
-            adjacentType: new WrappedNodeExpr(facade.type),
             bootstrap: facade.bootstrap.map(wrapReference),
             declarations: facade.declarations.map(wrapReference),
             publicDeclarationTypes: null,
@@ -19329,8 +19735,23 @@ class CompilerFacadeImpl {
         // Parse the template and check for errors.
         const { template, interpolation } = parseJitTemplate(facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces, facade.interpolation);
         // Compile the component metadata, including template, into an expression.
-        const meta = Object.assign(Object.assign(Object.assign({}, facade), convertDirectiveFacadeToMetadata(facade)), { selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(), template, declarations: facade.declarations.map(convertDeclarationFacadeToMetadata), declarationListEmitMode: 0 /* DeclarationListEmitMode.Direct */, styles: [...facade.styles, ...template.styles], encapsulation: facade.encapsulation, interpolation, changeDetection: facade.changeDetection, animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null, viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) :
-                null, relativeContextFilePath: '', i18nUseExternalIds: true });
+        const meta = {
+            ...facade,
+            ...convertDirectiveFacadeToMetadata(facade),
+            selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(),
+            template,
+            declarations: facade.declarations.map(convertDeclarationFacadeToMetadata),
+            declarationListEmitMode: 0 /* DeclarationListEmitMode.Direct */,
+            styles: [...facade.styles, ...template.styles],
+            encapsulation: facade.encapsulation,
+            interpolation,
+            changeDetection: facade.changeDetection,
+            animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null,
+            viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) :
+                null,
+            relativeContextFilePath: '',
+            i18nUseExternalIds: true,
+        };
         const jitExpressionSourceMap = `ng:///${facade.name}.js`;
         return this.compileComponentFromMeta(angularCoreEnv, jitExpressionSourceMap, meta);
     }
@@ -19349,7 +19770,6 @@ class CompilerFacadeImpl {
         const factoryRes = compileFactoryFunction({
             name: meta.name,
             type: wrapReference(meta.type),
-            internalType: new WrappedNodeExpr(meta.type),
             typeArgumentCount: meta.typeArgumentCount,
             deps: convertR3DependencyMetadataArray(meta.deps),
             target: meta.target,
@@ -19360,7 +19780,6 @@ class CompilerFacadeImpl {
         const factoryRes = compileFactoryFunction({
             name: meta.type.name,
             type: wrapReference(meta.type),
-            internalType: new WrappedNodeExpr(meta.type),
             typeArgumentCount: 0,
             deps: Array.isArray(meta.deps) ? meta.deps.map(convertR3DeclareDependencyMetadata) :
                 meta.deps,
@@ -19393,18 +19812,23 @@ class CompilerFacadeImpl {
     }
 }
 function convertToR3QueryMetadata(facade) {
-    return Object.assign(Object.assign({}, facade), { predicate: convertQueryPredicate(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static, emitDistinctChangesOnly: facade.emitDistinctChangesOnly });
+    return {
+        ...facade,
+        predicate: convertQueryPredicate(facade.predicate),
+        read: facade.read ? new WrappedNodeExpr(facade.read) : null,
+        static: facade.static,
+        emitDistinctChangesOnly: facade.emitDistinctChangesOnly,
+    };
 }
 function convertQueryDeclarationToMetadata(declaration) {
-    var _a, _b, _c, _d;
     return {
         propertyName: declaration.propertyName,
-        first: (_a = declaration.first) !== null && _a !== void 0 ? _a : false,
+        first: declaration.first ?? false,
         predicate: convertQueryPredicate(declaration.predicate),
-        descendants: (_b = declaration.descendants) !== null && _b !== void 0 ? _b : false,
+        descendants: declaration.descendants ?? false,
         read: declaration.read ? new WrappedNodeExpr(declaration.read) : null,
-        static: (_c = declaration.static) !== null && _c !== void 0 ? _c : false,
-        emitDistinctChangesOnly: (_d = declaration.emitDistinctChangesOnly) !== null && _d !== void 0 ? _d : true,
+        static: declaration.static ?? false,
+        emitDistinctChangesOnly: declaration.emitDistinctChangesOnly ?? true,
     };
 }
 function convertQueryPredicate(predicate) {
@@ -19415,8 +19839,8 @@ function convertQueryPredicate(predicate) {
         createMayBeForwardRefExpression(new WrappedNodeExpr(predicate), 1 /* ForwardRefHandling.Wrapped */);
 }
 function convertDirectiveFacadeToMetadata(facade) {
-    const inputsFromMetadata = parseInputOutputs(facade.inputs || []);
-    const outputsFromMetadata = parseInputOutputs(facade.outputs || []);
+    const inputsFromMetadata = parseInputsArray(facade.inputs || []);
+    const outputsFromMetadata = parseMappingStringArray(facade.outputs || []);
     const propMetadata = facade.propMetadata;
     const inputsFromType = {};
     const outputsFromType = {};
@@ -19424,48 +19848,62 @@ function convertDirectiveFacadeToMetadata(facade) {
         if (propMetadata.hasOwnProperty(field)) {
             propMetadata[field].forEach(ann => {
                 if (isInput(ann)) {
-                    inputsFromType[field] =
-                        ann.bindingPropertyName ? [ann.bindingPropertyName, field] : field;
+                    inputsFromType[field] = {
+                        bindingPropertyName: ann.alias || field,
+                        classPropertyName: field,
+                        required: ann.required || false
+                    };
                 }
                 else if (isOutput(ann)) {
-                    outputsFromType[field] = ann.bindingPropertyName || field;
+                    outputsFromType[field] = ann.alias || field;
                 }
             });
         }
     }
-    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, hostDirectives: convertHostDirectivesToMetadata(facade) });
+    return {
+        ...facade,
+        typeArgumentCount: 0,
+        typeSourceSpan: facade.typeSourceSpan,
+        type: wrapReference(facade.type),
+        deps: null,
+        host: extractHostBindings(facade.propMetadata, facade.typeSourceSpan, facade.host),
+        inputs: { ...inputsFromMetadata, ...inputsFromType },
+        outputs: { ...outputsFromMetadata, ...outputsFromType },
+        queries: facade.queries.map(convertToR3QueryMetadata),
+        providers: facade.providers != null ? new WrappedNodeExpr(facade.providers) : null,
+        viewQueries: facade.viewQueries.map(convertToR3QueryMetadata),
+        fullInheritance: false,
+        hostDirectives: convertHostDirectivesToMetadata(facade),
+    };
 }
 function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
         typeSourceSpan,
-        internalType: new WrappedNodeExpr(declaration.type),
-        selector: (_a = declaration.selector) !== null && _a !== void 0 ? _a : null,
-        inputs: (_b = declaration.inputs) !== null && _b !== void 0 ? _b : {},
-        outputs: (_c = declaration.outputs) !== null && _c !== void 0 ? _c : {},
+        selector: declaration.selector ?? null,
+        inputs: declaration.inputs ? inputsMappingToInputMetadata(declaration.inputs) : {},
+        outputs: declaration.outputs ?? {},
         host: convertHostDeclarationToMetadata(declaration.host),
-        queries: ((_d = declaration.queries) !== null && _d !== void 0 ? _d : []).map(convertQueryDeclarationToMetadata),
-        viewQueries: ((_e = declaration.viewQueries) !== null && _e !== void 0 ? _e : []).map(convertQueryDeclarationToMetadata),
+        queries: (declaration.queries ?? []).map(convertQueryDeclarationToMetadata),
+        viewQueries: (declaration.viewQueries ?? []).map(convertQueryDeclarationToMetadata),
         providers: declaration.providers !== undefined ? new WrappedNodeExpr(declaration.providers) :
             null,
-        exportAs: (_f = declaration.exportAs) !== null && _f !== void 0 ? _f : null,
-        usesInheritance: (_g = declaration.usesInheritance) !== null && _g !== void 0 ? _g : false,
-        lifecycle: { usesOnChanges: (_h = declaration.usesOnChanges) !== null && _h !== void 0 ? _h : false },
+        exportAs: declaration.exportAs ?? null,
+        usesInheritance: declaration.usesInheritance ?? false,
+        lifecycle: { usesOnChanges: declaration.usesOnChanges ?? false },
         deps: null,
         typeArgumentCount: 0,
         fullInheritance: false,
-        isStandalone: (_j = declaration.isStandalone) !== null && _j !== void 0 ? _j : false,
+        isStandalone: declaration.isStandalone ?? false,
         hostDirectives: convertHostDirectivesToMetadata(declaration),
     };
 }
 function convertHostDeclarationToMetadata(host = {}) {
-    var _a, _b, _c;
     return {
-        attributes: convertOpaqueValuesToExpressions((_a = host.attributes) !== null && _a !== void 0 ? _a : {}),
-        listeners: (_b = host.listeners) !== null && _b !== void 0 ? _b : {},
-        properties: (_c = host.properties) !== null && _c !== void 0 ? _c : {},
+        attributes: convertOpaqueValuesToExpressions(host.attributes ?? {}),
+        listeners: host.listeners ?? {},
+        properties: host.properties ?? {},
         specialAttributes: {
             classAttr: host.classAttribute,
             styleAttr: host.styleAttribute,
@@ -19473,8 +19911,7 @@ function convertHostDeclarationToMetadata(host = {}) {
     };
 }
 function convertHostDirectivesToMetadata(metadata) {
-    var _a;
-    if ((_a = metadata.hostDirectives) === null || _a === void 0 ? void 0 : _a.length) {
+    if (metadata.hostDirectives?.length) {
         return metadata.hostDirectives.map(hostDirective => {
             return typeof hostDirective === 'function' ?
                 {
@@ -19486,8 +19923,8 @@ function convertHostDirectivesToMetadata(metadata) {
                 {
                     directive: wrapReference(hostDirective.directive),
                     isForwardReference: false,
-                    inputs: hostDirective.inputs ? parseInputOutputs(hostDirective.inputs) : null,
-                    outputs: hostDirective.outputs ? parseInputOutputs(hostDirective.outputs) : null,
+                    inputs: hostDirective.inputs ? parseMappingStringArray(hostDirective.inputs) : null,
+                    outputs: hostDirective.outputs ? parseMappingStringArray(hostDirective.outputs) : null,
                 };
         });
     }
@@ -19501,8 +19938,7 @@ function convertOpaqueValuesToExpressions(obj) {
     return result;
 }
 function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMapUrl) {
-    var _a, _b, _c, _d;
-    const { template, interpolation } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, (_a = decl.preserveWhitespaces) !== null && _a !== void 0 ? _a : false, decl.interpolation);
+    const { template, interpolation } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, decl.preserveWhitespaces ?? false, decl.interpolation);
     const declarations = [];
     if (decl.dependencies) {
         for (const innerDep of decl.dependencies) {
@@ -19526,22 +19962,37 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
             declarations.push(...decl.directives.map(dir => convertDirectiveDeclarationToMetadata(dir)));
         decl.pipes && declarations.push(...convertPipeMapToMetadata(decl.pipes));
     }
-    return Object.assign(Object.assign({}, convertDeclareDirectiveFacadeToMetadata(decl, typeSourceSpan)), { template, styles: (_b = decl.styles) !== null && _b !== void 0 ? _b : [], declarations, viewProviders: decl.viewProviders !== undefined ? new WrappedNodeExpr(decl.viewProviders) :
-            null, animations: decl.animations !== undefined ? new WrappedNodeExpr(decl.animations) : null, changeDetection: (_c = decl.changeDetection) !== null && _c !== void 0 ? _c : exports.ChangeDetectionStrategy.Default, encapsulation: (_d = decl.encapsulation) !== null && _d !== void 0 ? _d : exports.ViewEncapsulation.Emulated, interpolation, declarationListEmitMode: 2 /* DeclarationListEmitMode.ClosureResolved */, relativeContextFilePath: '', i18nUseExternalIds: true });
+    return {
+        ...convertDeclareDirectiveFacadeToMetadata(decl, typeSourceSpan),
+        template,
+        styles: decl.styles ?? [],
+        declarations,
+        viewProviders: decl.viewProviders !== undefined ? new WrappedNodeExpr(decl.viewProviders) :
+            null,
+        animations: decl.animations !== undefined ? new WrappedNodeExpr(decl.animations) : null,
+        changeDetection: decl.changeDetection ?? exports.ChangeDetectionStrategy.Default,
+        encapsulation: decl.encapsulation ?? exports.ViewEncapsulation.Emulated,
+        interpolation,
+        declarationListEmitMode: 2 /* DeclarationListEmitMode.ClosureResolved */,
+        relativeContextFilePath: '',
+        i18nUseExternalIds: true,
+    };
 }
 function convertDeclarationFacadeToMetadata(declaration) {
-    return Object.assign(Object.assign({}, declaration), { type: new WrappedNodeExpr(declaration.type) });
+    return {
+        ...declaration,
+        type: new WrappedNodeExpr(declaration.type),
+    };
 }
 function convertDirectiveDeclarationToMetadata(declaration, isComponent = null) {
-    var _a, _b, _c;
     return {
         kind: exports.R3TemplateDependencyKind.Directive,
         isComponent: isComponent || declaration.kind === 'component',
         selector: declaration.selector,
         type: new WrappedNodeExpr(declaration.type),
-        inputs: (_a = declaration.inputs) !== null && _a !== void 0 ? _a : [],
-        outputs: (_b = declaration.outputs) !== null && _b !== void 0 ? _b : [],
-        exportAs: (_c = declaration.exportAs) !== null && _c !== void 0 ? _c : null,
+        inputs: declaration.inputs ?? [],
+        outputs: declaration.outputs ?? [],
+        exportAs: declaration.exportAs ?? null,
     };
 }
 function convertPipeMapToMetadata(pipes) {
@@ -19599,7 +20050,7 @@ function wrapExpression(obj, property) {
 }
 function computeProvidedIn(providedIn) {
     const expression = typeof providedIn === 'function' ? new WrappedNodeExpr(providedIn) :
-        new LiteralExpr(providedIn !== null && providedIn !== void 0 ? providedIn : null);
+        new LiteralExpr(providedIn ?? null);
     // See `convertToProviderExpression()` for why this uses `ForwardRefHandling.None`.
     return createMayBeForwardRefExpression(expression, 0 /* ForwardRefHandling.None */);
 }
@@ -19615,10 +20066,9 @@ function convertR3DependencyMetadata(facade) {
     return createR3DependencyMetadata(token, isAttributeDep, facade.host, facade.optional, facade.self, facade.skipSelf);
 }
 function convertR3DeclareDependencyMetadata(facade) {
-    var _a, _b, _c, _d, _e;
-    const isAttributeDep = (_a = facade.attribute) !== null && _a !== void 0 ? _a : false;
+    const isAttributeDep = facade.attribute ?? false;
     const token = facade.token === null ? null : new WrappedNodeExpr(facade.token);
-    return createR3DependencyMetadata(token, isAttributeDep, (_b = facade.host) !== null && _b !== void 0 ? _b : false, (_c = facade.optional) !== null && _c !== void 0 ? _c : false, (_d = facade.self) !== null && _d !== void 0 ? _d : false, (_e = facade.skipSelf) !== null && _e !== void 0 ? _e : false);
+    return createR3DependencyMetadata(token, isAttributeDep, facade.host ?? false, facade.optional ?? false, facade.self ?? false, facade.skipSelf ?? false);
 }
 function createR3DependencyMetadata(token, isAttributeDep, host, optional, self, skipSelf) {
     // If the dep is an `@Attribute()` the `attributeNameType` ought to be the `unknown` type.
@@ -19666,31 +20116,59 @@ function isInput(value) {
 function isOutput(value) {
     return value.ngMetadataName === 'Output';
 }
-function parseInputOutputs(values) {
+function inputsMappingToInputMetadata(inputs) {
+    return Object.keys(inputs).reduce((result, key) => {
+        const value = inputs[key];
+        result[key] = typeof value === 'string' ?
+            { bindingPropertyName: value, classPropertyName: value, required: false } :
+            { bindingPropertyName: value[0], classPropertyName: value[1], required: false };
+        return result;
+    }, {});
+}
+function parseInputsArray(values) {
+    return values.reduce((results, value) => {
+        if (typeof value === 'string') {
+            const [bindingPropertyName, classPropertyName] = parseMappingString(value);
+            results[classPropertyName] = { bindingPropertyName, classPropertyName, required: false };
+        }
+        else {
+            results[value.name] = {
+                bindingPropertyName: value.alias || value.name,
+                classPropertyName: value.name,
+                required: value.required || false
+            };
+        }
+        return results;
+    }, {});
+}
+function parseMappingStringArray(values) {
     return values.reduce((results, value) => {
-        const [field, property] = value.split(':', 2).map(str => str.trim());
-        results[field] = property || field;
+        const [alias, fieldName] = parseMappingString(value);
+        results[fieldName] = alias;
         return results;
     }, {});
 }
+function parseMappingString(value) {
+    // Either the value is 'field' or 'field: property'. In the first case, `property` will
+    // be undefined, in which case the field name should also be used as the property name.
+    const [fieldName, bindingPropertyName] = value.split(':', 2).map(str => str.trim());
+    return [bindingPropertyName ?? fieldName, fieldName];
+}
 function convertDeclarePipeFacadeToMetadata(declaration) {
-    var _a, _b;
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
-        internalType: new WrappedNodeExpr(declaration.type),
         typeArgumentCount: 0,
         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,
+        pure: declaration.pure ?? true,
+        isStandalone: declaration.isStandalone ?? false,
     };
 }
 function convertDeclareInjectorFacadeToMetadata(declaration) {
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
-        internalType: new WrappedNodeExpr(declaration.type),
         providers: declaration.providers !== undefined && declaration.providers.length > 0 ?
             new WrappedNodeExpr(declaration.providers) :
             null,
@@ -19709,7 +20187,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('15.2.5');
+const VERSION = new Version('16.0.0-rc.2');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = exports.ViewEncapsulation.Emulated, useJit = true, missingTranslation = null, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -20117,6 +20595,7 @@ function _parseMessageMeta(i18n) {
 class XmlTagDefinition {
     constructor() {
         this.closedByParent = false;
+        this.implicitNamespacePrefix = null;
         this.isVoid = false;
         this.ignoreFirstLf = false;
         this.canSelfClose = true;
@@ -20458,6 +20937,9 @@ class Xliff2 extends Serializer {
     }
 }
 class _WriteVisitor {
+    constructor() {
+        this._nextPlaceholderId = 0;
+    }
     visitText(text, context) {
         return [new Text$1(text.value)];
     }
@@ -20887,8 +21369,8 @@ class I18nToHtmlVisitor {
         this._mapperFactory = _mapperFactory;
         this._missingTranslationStrategy = _missingTranslationStrategy;
         this._console = _console;
-        this._contextStack = [];
         this._errors = [];
+        this._contextStack = [];
     }
     convert(srcMsg) {
         this._contextStack.length = 0;
@@ -21011,7 +21493,7 @@ class I18NHtmlParser {
     }
     parse(source, url, options = {}) {
         const interpolationConfig = options.interpolationConfig || DEFAULT_INTERPOLATION_CONFIG;
-        const parseResult = this._htmlParser.parse(source, url, Object.assign({ interpolationConfig }, options));
+        const parseResult = this._htmlParser.parse(source, url, { interpolationConfig, ...options });
         if (parseResult.errors.length) {
             return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);
         }
@@ -21548,8 +22030,7 @@ class R3BoundTarget {
         this.usedPipes = usedPipes;
     }
     getEntitiesInTemplateScope(template) {
-        var _a;
-        return (_a = this.templateEntities.get(template)) !== null && _a !== void 0 ? _a : new Set();
+        return this.templateEntities.get(template) ?? new Set();
     }
     getDirectivesOfNode(node) {
         return this.directives.get(node) || null;
@@ -21611,14 +22092,13 @@ function extractTemplateEntities(rootScope) {
 }
 
 function compileClassMetadata(metadata) {
-    var _a, _b;
     // Generate an ngDevMode guarded call to setClassMetadata with the class identifier and its
     // metadata.
     const fnCall = importExpr(Identifiers.setClassMetadata).callFn([
         metadata.type,
         metadata.decorators,
-        (_a = metadata.ctorParameters) !== null && _a !== void 0 ? _a : literal(null),
-        (_b = metadata.propDecorators) !== null && _b !== void 0 ? _b : literal(null),
+        metadata.ctorParameters ?? literal(null),
+        metadata.propDecorators ?? literal(null),
     ]);
     const iife = fn([], [devOnlyGuardedExpression(fnCall).toStmt()]);
     return iife.callFn([]);
@@ -21635,7 +22115,7 @@ 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('15.2.5'));
+    definitionMap.set('version', literal('16.0.0-rc.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -21736,12 +22216,11 @@ function compileDeclareDirectiveFromMetadata(meta) {
  * this logic for components, as they extend the directive metadata.
  */
 function createDirectiveDefinitionMap(meta) {
-    var _a;
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('15.2.5'));
+    definitionMap.set('version', literal('16.0.0-rc.2'));
     // e.g. `type: MyDirective`
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
         definitionMap.set('isStandalone', literal(meta.isStandalone));
     }
@@ -21749,8 +22228,8 @@ function createDirectiveDefinitionMap(meta) {
     if (meta.selector !== null) {
         definitionMap.set('selector', literal(meta.selector));
     }
-    definitionMap.set('inputs', conditionallyCreateMapObjectLiteral(meta.inputs, true));
-    definitionMap.set('outputs', conditionallyCreateMapObjectLiteral(meta.outputs));
+    definitionMap.set('inputs', conditionallyCreateDirectiveBindingLiteral(meta.inputs, true));
+    definitionMap.set('outputs', conditionallyCreateDirectiveBindingLiteral(meta.outputs));
     definitionMap.set('host', compileHostMetadata(meta.host));
     definitionMap.set('providers', meta.providers);
     if (meta.queries.length > 0) {
@@ -21768,7 +22247,7 @@ function createDirectiveDefinitionMap(meta) {
     if (meta.lifecycle.usesOnChanges) {
         definitionMap.set('usesOnChanges', literal(true));
     }
-    if ((_a = meta.hostDirectives) === null || _a === void 0 ? void 0 : _a.length) {
+    if (meta.hostDirectives?.length) {
         definitionMap.set('hostDirectives', createHostDirectives(meta.hostDirectives));
     }
     definitionMap.set('ngImport', importExpr(Identifiers.core));
@@ -21961,9 +22440,9 @@ 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('15.2.5'));
+    definitionMap.set('version', literal('16.0.0-rc.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
     definitionMap.set('target', importExpr(Identifiers.FactoryTarget).prop(exports.FactoryTarget[meta.target]));
     return {
@@ -21996,9 +22475,9 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('15.2.5'));
+    definitionMap.set('version', literal('16.0.0-rc.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
     if (meta.providedIn !== undefined) {
         const providedIn = convertFromMaybeForwardRefExpression(meta.providedIn);
@@ -22047,9 +22526,9 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('15.2.5'));
+    definitionMap.set('version', literal('16.0.0-rc.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
     if (meta.imports.length > 0) {
         definitionMap.set('imports', literalArr(meta.imports));
@@ -22077,9 +22556,9 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('15.2.5'));
+    definitionMap.set('version', literal('16.0.0-rc.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     // 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
     // not-yet-declared class. This is to support JIT execution of the `ɵɵngDeclareNgModule()` call.
@@ -22128,10 +22607,10 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('15.2.5'));
+    definitionMap.set('version', literal('16.0.0-rc.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
         definitionMap.set('isStandalone', literal(meta.isStandalone));
     }