@angular/compiler 20.0.0-next.3 → 20.0.0-next.5

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v20.0.0-next.3
+ * @license Angular v20.0.0-next.5
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1320,14 +1320,13 @@ class TemplateLiteralElementExpr extends Expression {
     constructor(text, sourceSpan, rawText) {
         super(STRING_TYPE, sourceSpan);
         this.text = text;
-        // If `rawText` is not provided, try to extract the raw string from its
-        // associated `sourceSpan`. If that is also not available, "fake" the raw
-        // string instead by escaping the following control sequences:
+        // If `rawText` is not provided, "fake" the raw string by escaping the following sequences:
         // - "\" would otherwise indicate that the next character is a control character.
         // - "`" and "${" are template string control sequences that would otherwise prematurely
         // indicate the end of the template literal element.
-        this.rawText =
-            rawText ?? sourceSpan?.toString() ?? escapeForTemplateLiteral(escapeSlashes(text));
+        // Note that we can't rely on the `sourceSpan` here, because it may be incorrect (see
+        // https://github.com/angular/angular/pull/60267#discussion_r1986402524).
+        this.rawText = rawText ?? escapeForTemplateLiteral(escapeSlashes(text));
     }
     visitExpression(visitor, context) {
         return visitor.visitTemplateLiteralElementExpr(this, context);
@@ -2896,6 +2895,11 @@ class Identifiers {
         name: 'ɵɵdeferEnableTimerScheduling',
         moduleName: CORE,
     };
+    static conditionalCreate = { name: 'ɵɵconditionalCreate', moduleName: CORE };
+    static conditionalBranchCreate = {
+        name: 'ɵɵconditionalBranchCreate',
+        moduleName: CORE,
+    };
     static conditional = { name: 'ɵɵconditional', moduleName: CORE };
     static repeater = { name: 'ɵɵrepeater', moduleName: CORE };
     static repeaterCreate = { name: 'ɵɵrepeaterCreate', moduleName: CORE };
@@ -2938,7 +2942,7 @@ class Identifiers {
     static pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE };
     static pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE };
     static pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE };
-    static hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE };
+    static domProperty = { name: 'ɵɵdomProperty', moduleName: CORE };
     static property = { name: 'ɵɵproperty', moduleName: CORE };
     static propertyInterpolate = {
         name: 'ɵɵpropertyInterpolate',
@@ -8729,167 +8733,175 @@ var OpKind;
      * node.
      */
     OpKind[OpKind["DisableBindings"] = 10] = "DisableBindings";
+    /**
+     * Create a conditional creation instruction op.
+     */
+    OpKind[OpKind["ConditionalCreate"] = 11] = "ConditionalCreate";
+    /**
+     * Create a conditional branch creation instruction op.
+     */
+    OpKind[OpKind["ConditionalBranchCreate"] = 12] = "ConditionalBranchCreate";
     /**
      * An op to conditionally render a template.
      */
-    OpKind[OpKind["Conditional"] = 11] = "Conditional";
+    OpKind[OpKind["Conditional"] = 13] = "Conditional";
     /**
      * An operation to re-enable binding, after it was previously disabled.
      */
-    OpKind[OpKind["EnableBindings"] = 12] = "EnableBindings";
+    OpKind[OpKind["EnableBindings"] = 14] = "EnableBindings";
     /**
      * An operation to render a text node.
      */
-    OpKind[OpKind["Text"] = 13] = "Text";
+    OpKind[OpKind["Text"] = 15] = "Text";
     /**
      * An operation declaring an event listener for an element.
      */
-    OpKind[OpKind["Listener"] = 14] = "Listener";
+    OpKind[OpKind["Listener"] = 16] = "Listener";
     /**
      * An operation to interpolate text into a text node.
      */
-    OpKind[OpKind["InterpolateText"] = 15] = "InterpolateText";
+    OpKind[OpKind["InterpolateText"] = 17] = "InterpolateText";
     /**
      * An intermediate binding op, that has not yet been processed into an individual property,
      * attribute, style, etc.
      */
-    OpKind[OpKind["Binding"] = 16] = "Binding";
+    OpKind[OpKind["Binding"] = 18] = "Binding";
     /**
      * An operation to bind an expression to a property of an element.
      */
-    OpKind[OpKind["Property"] = 17] = "Property";
+    OpKind[OpKind["Property"] = 19] = "Property";
     /**
      * An operation to bind an expression to a style property of an element.
      */
-    OpKind[OpKind["StyleProp"] = 18] = "StyleProp";
+    OpKind[OpKind["StyleProp"] = 20] = "StyleProp";
     /**
      * An operation to bind an expression to a class property of an element.
      */
-    OpKind[OpKind["ClassProp"] = 19] = "ClassProp";
+    OpKind[OpKind["ClassProp"] = 21] = "ClassProp";
     /**
      * An operation to bind an expression to the styles of an element.
      */
-    OpKind[OpKind["StyleMap"] = 20] = "StyleMap";
+    OpKind[OpKind["StyleMap"] = 22] = "StyleMap";
     /**
      * An operation to bind an expression to the classes of an element.
      */
-    OpKind[OpKind["ClassMap"] = 21] = "ClassMap";
+    OpKind[OpKind["ClassMap"] = 23] = "ClassMap";
     /**
      * An operation to advance the runtime's implicit slot context during the update phase of a view.
      */
-    OpKind[OpKind["Advance"] = 22] = "Advance";
+    OpKind[OpKind["Advance"] = 24] = "Advance";
     /**
      * An operation to instantiate a pipe.
      */
-    OpKind[OpKind["Pipe"] = 23] = "Pipe";
+    OpKind[OpKind["Pipe"] = 25] = "Pipe";
     /**
      * An operation to associate an attribute with an element.
      */
-    OpKind[OpKind["Attribute"] = 24] = "Attribute";
+    OpKind[OpKind["Attribute"] = 26] = "Attribute";
     /**
      * An attribute that has been extracted for inclusion in the consts array.
      */
-    OpKind[OpKind["ExtractedAttribute"] = 25] = "ExtractedAttribute";
+    OpKind[OpKind["ExtractedAttribute"] = 27] = "ExtractedAttribute";
     /**
      * An operation that configures a `@defer` block.
      */
-    OpKind[OpKind["Defer"] = 26] = "Defer";
+    OpKind[OpKind["Defer"] = 28] = "Defer";
     /**
      * An operation that controls when a `@defer` loads.
      */
-    OpKind[OpKind["DeferOn"] = 27] = "DeferOn";
+    OpKind[OpKind["DeferOn"] = 29] = "DeferOn";
     /**
      * An operation that controls when a `@defer` loads, using a custom expression as the condition.
      */
-    OpKind[OpKind["DeferWhen"] = 28] = "DeferWhen";
+    OpKind[OpKind["DeferWhen"] = 30] = "DeferWhen";
     /**
      * An i18n message that has been extracted for inclusion in the consts array.
      */
-    OpKind[OpKind["I18nMessage"] = 29] = "I18nMessage";
+    OpKind[OpKind["I18nMessage"] = 31] = "I18nMessage";
     /**
-     * A host binding property.
+     * A binding to a native DOM property.
      */
-    OpKind[OpKind["HostProperty"] = 30] = "HostProperty";
+    OpKind[OpKind["DomProperty"] = 32] = "DomProperty";
     /**
      * A namespace change, which causes the subsequent elements to be processed as either HTML or SVG.
      */
-    OpKind[OpKind["Namespace"] = 31] = "Namespace";
+    OpKind[OpKind["Namespace"] = 33] = "Namespace";
     /**
      * Configure a content projeciton definition for the view.
      */
-    OpKind[OpKind["ProjectionDef"] = 32] = "ProjectionDef";
+    OpKind[OpKind["ProjectionDef"] = 34] = "ProjectionDef";
     /**
      * Create a content projection slot.
      */
-    OpKind[OpKind["Projection"] = 33] = "Projection";
+    OpKind[OpKind["Projection"] = 35] = "Projection";
     /**
      * Create a repeater creation instruction op.
      */
-    OpKind[OpKind["RepeaterCreate"] = 34] = "RepeaterCreate";
+    OpKind[OpKind["RepeaterCreate"] = 36] = "RepeaterCreate";
     /**
      * An update up for a repeater.
      */
-    OpKind[OpKind["Repeater"] = 35] = "Repeater";
+    OpKind[OpKind["Repeater"] = 37] = "Repeater";
     /**
      * An operation to bind an expression to the property side of a two-way binding.
      */
-    OpKind[OpKind["TwoWayProperty"] = 36] = "TwoWayProperty";
+    OpKind[OpKind["TwoWayProperty"] = 38] = "TwoWayProperty";
     /**
      * An operation declaring the event side of a two-way binding.
      */
-    OpKind[OpKind["TwoWayListener"] = 37] = "TwoWayListener";
+    OpKind[OpKind["TwoWayListener"] = 39] = "TwoWayListener";
     /**
      * A creation-time operation that initializes the slot for a `@let` declaration.
      */
-    OpKind[OpKind["DeclareLet"] = 38] = "DeclareLet";
+    OpKind[OpKind["DeclareLet"] = 40] = "DeclareLet";
     /**
      * An update-time operation that stores the current value of a `@let` declaration.
      */
-    OpKind[OpKind["StoreLet"] = 39] = "StoreLet";
+    OpKind[OpKind["StoreLet"] = 41] = "StoreLet";
     /**
      * The start of an i18n block.
      */
-    OpKind[OpKind["I18nStart"] = 40] = "I18nStart";
+    OpKind[OpKind["I18nStart"] = 42] = "I18nStart";
     /**
      * A self-closing i18n on a single element.
      */
-    OpKind[OpKind["I18n"] = 41] = "I18n";
+    OpKind[OpKind["I18n"] = 43] = "I18n";
     /**
      * The end of an i18n block.
      */
-    OpKind[OpKind["I18nEnd"] = 42] = "I18nEnd";
+    OpKind[OpKind["I18nEnd"] = 44] = "I18nEnd";
     /**
      * An expression in an i18n message.
      */
-    OpKind[OpKind["I18nExpression"] = 43] = "I18nExpression";
+    OpKind[OpKind["I18nExpression"] = 45] = "I18nExpression";
     /**
      * An instruction that applies a set of i18n expressions.
      */
-    OpKind[OpKind["I18nApply"] = 44] = "I18nApply";
+    OpKind[OpKind["I18nApply"] = 46] = "I18nApply";
     /**
      * An instruction to create an ICU expression.
      */
-    OpKind[OpKind["IcuStart"] = 45] = "IcuStart";
+    OpKind[OpKind["IcuStart"] = 47] = "IcuStart";
     /**
      * An instruction to update an ICU expression.
      */
-    OpKind[OpKind["IcuEnd"] = 46] = "IcuEnd";
+    OpKind[OpKind["IcuEnd"] = 48] = "IcuEnd";
     /**
      * An instruction representing a placeholder in an ICU expression.
      */
-    OpKind[OpKind["IcuPlaceholder"] = 47] = "IcuPlaceholder";
+    OpKind[OpKind["IcuPlaceholder"] = 49] = "IcuPlaceholder";
     /**
      * An i18n context containing information needed to generate an i18n message.
      */
-    OpKind[OpKind["I18nContext"] = 48] = "I18nContext";
+    OpKind[OpKind["I18nContext"] = 50] = "I18nContext";
     /**
      * A creation op that corresponds to i18n attributes on an element.
      */
-    OpKind[OpKind["I18nAttributes"] = 49] = "I18nAttributes";
+    OpKind[OpKind["I18nAttributes"] = 51] = "I18nAttributes";
     /**
      * Creation op that attaches the location at which an element was defined in a template to it.
      */
-    OpKind[OpKind["SourceLocation"] = 50] = "SourceLocation";
+    OpKind[OpKind["SourceLocation"] = 52] = "SourceLocation";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -10316,7 +10328,7 @@ function transformExpressionsInOp(op, transform, flags) {
             }
             break;
         case OpKind.Property:
-        case OpKind.HostProperty:
+        case OpKind.DomProperty:
         case OpKind.Attribute:
             if (op.expression instanceof Interpolation) {
                 transformExpressionsInInterpolation(op.expression, transform, flags);
@@ -10439,6 +10451,8 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.IcuPlaceholder:
         case OpKind.DeclareLet:
         case OpKind.SourceLocation:
+        case OpKind.ConditionalCreate:
+        case OpKind.ConditionalBranchCreate:
             // These operations contain no expressions.
             break;
         default:
@@ -10854,6 +10868,8 @@ const elementContainerOpKinds = new Set([
     OpKind.ContainerStart,
     OpKind.Template,
     OpKind.RepeaterCreate,
+    OpKind.ConditionalCreate,
+    OpKind.ConditionalBranchCreate,
 ]);
 /**
  * Checks whether the given operation represents the creation of an element or container.
@@ -10905,6 +10921,48 @@ function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace
         ...NEW_OP,
     };
 }
+function createConditionalCreateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, startSourceSpan, wholeSourceSpan) {
+    return {
+        kind: OpKind.ConditionalCreate,
+        xref,
+        templateKind,
+        attributes: null,
+        tag,
+        handle: new SlotHandle(),
+        functionNameSuffix,
+        decls: null,
+        vars: null,
+        localRefs: [],
+        nonBindable: false,
+        namespace,
+        i18nPlaceholder,
+        startSourceSpan,
+        wholeSourceSpan,
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+    };
+}
+function createConditionalBranchCreateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, startSourceSpan, wholeSourceSpan) {
+    return {
+        kind: OpKind.ConditionalBranchCreate,
+        xref,
+        templateKind,
+        attributes: null,
+        tag,
+        handle: new SlotHandle(),
+        functionNameSuffix,
+        decls: null,
+        vars: null,
+        localRefs: [],
+        nonBindable: false,
+        namespace,
+        i18nPlaceholder,
+        startSourceSpan,
+        wholeSourceSpan,
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+    };
+}
 function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, emptyTag, i18nPlaceholder, emptyI18nPlaceholder, startSourceSpan, wholeSourceSpan) {
     return {
         kind: OpKind.RepeaterCreate,
@@ -11248,9 +11306,9 @@ function createSourceLocationOp(templatePath, locations) {
     };
 }
 
-function createHostPropertyOp(name, expression, isAnimationTrigger, i18nContext, securityContext, sourceSpan) {
+function createDomPropertyOp(name, expression, isAnimationTrigger, i18nContext, securityContext, sourceSpan) {
     return {
-        kind: OpKind.HostProperty,
+        kind: OpKind.DomProperty,
         name,
         expression,
         isAnimationTrigger,
@@ -11828,7 +11886,7 @@ function specializeBindings(job) {
                 case BindingKind.Property:
                 case BindingKind.Animation:
                     if (job.kind === CompilationJobKind.Host) {
-                        OpList.replace(op, createHostPropertyOp(op.name, op.expression, op.bindingKind === BindingKind.Animation, op.i18nContext, op.securityContext, op.sourceSpan));
+                        OpList.replace(op, createDomPropertyOp(op.name, op.expression, op.bindingKind === BindingKind.Animation, op.i18nContext, op.securityContext, op.sourceSpan));
                     }
                     else {
                         OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind === BindingKind.Animation, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
@@ -11852,36 +11910,38 @@ function specializeBindings(job) {
     }
 }
 
-const CHAINABLE = new Set([
-    Identifiers.attribute,
-    Identifiers.classProp,
-    Identifiers.element,
-    Identifiers.elementContainer,
-    Identifiers.elementContainerEnd,
-    Identifiers.elementContainerStart,
-    Identifiers.elementEnd,
-    Identifiers.elementStart,
-    Identifiers.hostProperty,
-    Identifiers.i18nExp,
-    Identifiers.listener,
-    Identifiers.listener,
-    Identifiers.property,
-    Identifiers.styleProp,
-    Identifiers.stylePropInterpolate1,
-    Identifiers.stylePropInterpolate2,
-    Identifiers.stylePropInterpolate3,
-    Identifiers.stylePropInterpolate4,
-    Identifiers.stylePropInterpolate5,
-    Identifiers.stylePropInterpolate6,
-    Identifiers.stylePropInterpolate7,
-    Identifiers.stylePropInterpolate8,
-    Identifiers.stylePropInterpolateV,
-    Identifiers.syntheticHostListener,
-    Identifiers.syntheticHostProperty,
-    Identifiers.templateCreate,
-    Identifiers.twoWayProperty,
-    Identifiers.twoWayListener,
-    Identifiers.declareLet,
+const CHAIN_COMPATIBILITY = new Map([
+    [Identifiers.attribute, Identifiers.attribute],
+    [Identifiers.classProp, Identifiers.classProp],
+    [Identifiers.element, Identifiers.element],
+    [Identifiers.elementContainer, Identifiers.elementContainer],
+    [Identifiers.elementContainerEnd, Identifiers.elementContainerEnd],
+    [Identifiers.elementContainerStart, Identifiers.elementContainerStart],
+    [Identifiers.elementEnd, Identifiers.elementEnd],
+    [Identifiers.elementStart, Identifiers.elementStart],
+    [Identifiers.domProperty, Identifiers.domProperty],
+    [Identifiers.i18nExp, Identifiers.i18nExp],
+    [Identifiers.listener, Identifiers.listener],
+    [Identifiers.listener, Identifiers.listener],
+    [Identifiers.property, Identifiers.property],
+    [Identifiers.styleProp, Identifiers.styleProp],
+    [Identifiers.stylePropInterpolate1, Identifiers.stylePropInterpolate1],
+    [Identifiers.stylePropInterpolate2, Identifiers.stylePropInterpolate2],
+    [Identifiers.stylePropInterpolate3, Identifiers.stylePropInterpolate3],
+    [Identifiers.stylePropInterpolate4, Identifiers.stylePropInterpolate4],
+    [Identifiers.stylePropInterpolate5, Identifiers.stylePropInterpolate5],
+    [Identifiers.stylePropInterpolate6, Identifiers.stylePropInterpolate6],
+    [Identifiers.stylePropInterpolate7, Identifiers.stylePropInterpolate7],
+    [Identifiers.stylePropInterpolate8, Identifiers.stylePropInterpolate8],
+    [Identifiers.stylePropInterpolateV, Identifiers.stylePropInterpolateV],
+    [Identifiers.syntheticHostListener, Identifiers.syntheticHostListener],
+    [Identifiers.syntheticHostProperty, Identifiers.syntheticHostProperty],
+    [Identifiers.templateCreate, Identifiers.templateCreate],
+    [Identifiers.twoWayProperty, Identifiers.twoWayProperty],
+    [Identifiers.twoWayListener, Identifiers.twoWayListener],
+    [Identifiers.declareLet, Identifiers.declareLet],
+    [Identifiers.conditionalCreate, Identifiers.conditionalBranchCreate],
+    [Identifiers.conditionalBranchCreate, Identifiers.conditionalBranchCreate],
 ]);
 /**
  * Chaining results in repeated call expressions, causing a deep AST of receiver expressions. To prevent running out of
@@ -11927,14 +11987,16 @@ function chainOperationsInList(opList) {
             continue;
         }
         const instruction = op.statement.expr.fn.value;
-        if (!CHAINABLE.has(instruction)) {
+        if (!CHAIN_COMPATIBILITY.has(instruction)) {
             // This instruction isn't chainable.
             chain = null;
             continue;
         }
         // This instruction can be chained. It can either be added on to the previous chain (if
         // compatible) or it can be the start of a new chain.
-        if (chain !== null && chain.instruction === instruction && chain.length < MAX_CHAIN_LENGTH) {
+        if (chain !== null &&
+            CHAIN_COMPATIBILITY.get(chain.instruction) === instruction &&
+            chain.length < MAX_CHAIN_LENGTH) {
             // This instruction can be added onto the previous chain.
             const expression = chain.expression.callFn(op.statement.expr.args, op.statement.expr.sourceSpan, op.statement.expr.pure);
             chain.expression = expression;
@@ -13153,6 +13215,8 @@ function recursivelyProcessView(view, parentScope) {
     const scope = getScopeForView(view, parentScope);
     for (const op of view.create) {
         switch (op.kind) {
+            case OpKind.ConditionalCreate:
+            case OpKind.ConditionalBranchCreate:
             case OpKind.Template:
                 // Descend into child embedded views.
                 recursivelyProcessView(view.job.views.get(op.xref), scope);
@@ -13210,6 +13274,8 @@ function getScopeForView(view, parent) {
     for (const op of view.create) {
         switch (op.kind) {
             case OpKind.ElementStart:
+            case OpKind.ConditionalCreate:
+            case OpKind.ConditionalBranchCreate:
             case OpKind.Template:
                 if (!Array.isArray(op.localRefs)) {
                     throw new Error(`AssertionError: expected localRefs to be an array`);
@@ -16259,7 +16325,7 @@ class _Tokenizer {
             else {
                 const name = this._cursor.getChars(nameStart);
                 this._cursor.advance();
-                const char = NAMED_ENTITIES[name];
+                const char = NAMED_ENTITIES.hasOwnProperty(name) && NAMED_ENTITIES[name];
                 if (!char) {
                     throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
                 }
@@ -19894,6 +19960,7 @@ const SCHEMA = [
     'q,blockquote,cite^[HTMLElement]|',
     'script^[HTMLElement]|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,!noModule,%referrerPolicy,src,text,type',
     'select^[HTMLElement]|autocomplete,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value',
+    'selectedcontent^[HTMLElement]|',
     'slot^[HTMLElement]|name',
     'source^[HTMLElement]|#height,media,sizes,src,srcset,type,#width',
     'span^[HTMLElement]|',
@@ -21740,6 +21807,8 @@ function liftLocalRefs(job) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.ElementStart:
+                case OpKind.ConditionalCreate:
+                case OpKind.ConditionalBranchCreate:
                 case OpKind.Template:
                     if (!Array.isArray(op.localRefs)) {
                         throw new Error(`AssertionError: expected localRefs to be an array still`);
@@ -21882,7 +21951,9 @@ function parseExtractedStyles(job) {
                 isStringLiteral(op.expression)) {
                 const target = elements.get(op.target);
                 if (target !== undefined &&
-                    target.kind === OpKind.Template &&
+                    (target.kind === OpKind.Template ||
+                        target.kind === OpKind.ConditionalCreate ||
+                        target.kind === OpKind.ConditionalBranchCreate) &&
                     target.templateKind === TemplateKind.Structural) {
                     // TemplateDefinitionBuilder will not apply class and style bindings to structural
                     // directives; instead, it will leave them as attributes.
@@ -21933,7 +22004,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
     for (const op of unit.ops()) {
         switch (op.kind) {
             case OpKind.Property:
-            case OpKind.HostProperty:
+            case OpKind.DomProperty:
                 if (op.isAnimationTrigger) {
                     op.name = '@' + op.name;
                 }
@@ -21997,6 +22068,8 @@ function addNamesToView(unit, baseName, state, compatibility) {
                     addNamesToView(fallbackView, `${baseName}_ProjectionFallback_${op.handle.slot}`, state, compatibility);
                 }
                 break;
+            case OpKind.ConditionalCreate:
+            case OpKind.ConditionalBranchCreate:
             case OpKind.Template:
                 if (!(unit instanceof ViewCompilationUnit)) {
                     throw new Error(`AssertionError: must be compiling a component`);
@@ -22247,8 +22320,8 @@ const UPDATE_ORDERING = [
  * Host bindings have their own update ordering.
  */
 const UPDATE_HOST_ORDERING = [
-    { test: kindWithInterpolationTest(OpKind.HostProperty, true) },
-    { test: kindWithInterpolationTest(OpKind.HostProperty, false) },
+    { test: kindWithInterpolationTest(OpKind.DomProperty, true) },
+    { test: kindWithInterpolationTest(OpKind.DomProperty, false) },
     { test: kindTest(OpKind.Attribute) },
     { test: kindTest(OpKind.StyleMap), transform: keepLast },
     { test: kindTest(OpKind.ClassMap), transform: keepLast },
@@ -22267,7 +22340,7 @@ const handledOpKinds = new Set([
     OpKind.ClassProp,
     OpKind.Property,
     OpKind.TwoWayProperty,
-    OpKind.HostProperty,
+    OpKind.DomProperty,
     OpKind.Attribute,
 ]);
 /**
@@ -22482,6 +22555,8 @@ function propagateI18nBlocksToTemplates(unit, subTemplateIndex) {
                 }
                 i18nBlock = null;
                 break;
+            case OpKind.ConditionalCreate:
+            case OpKind.ConditionalBranchCreate:
             case OpKind.Template:
                 subTemplateIndex = propagateI18nBlocksForView(unit.job.views.get(op.xref), i18nBlock, op.i18nPlaceholder, subTemplateIndex);
                 break;
@@ -22846,6 +22921,42 @@ function i18nStart(slot, constIndex, subTemplateIndex, sourceSpan) {
     }
     return call(Identifiers.i18nStart, args, sourceSpan);
 }
+function conditionalCreate(slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan) {
+    const args = [
+        literal(slot),
+        templateFnRef,
+        literal(decls),
+        literal(vars),
+        literal(tag),
+        literal(constIndex),
+    ];
+    if (localRefs !== null) {
+        args.push(literal(localRefs));
+        args.push(importExpr(Identifiers.templateRefExtractor));
+    }
+    while (args[args.length - 1].isEquivalent(NULL_EXPR)) {
+        args.pop();
+    }
+    return call(Identifiers.conditionalCreate, args, sourceSpan);
+}
+function conditionalBranchCreate(slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan) {
+    const args = [
+        literal(slot),
+        templateFnRef,
+        literal(decls),
+        literal(vars),
+        literal(tag),
+        literal(constIndex),
+    ];
+    if (localRefs !== null) {
+        args.push(literal(localRefs));
+        args.push(importExpr(Identifiers.templateRefExtractor));
+    }
+    while (args[args.length - 1].isEquivalent(NULL_EXPR)) {
+        args.pop();
+    }
+    return call(Identifiers.conditionalBranchCreate, args, sourceSpan);
+}
 function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByFn, trackByUsesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, emptyTag, emptyConstIndex, sourceSpan) {
     const args = [
         literal(slot),
@@ -23003,12 +23114,12 @@ function classMapInterpolate(strings, expressions, sourceSpan) {
     const interpolationArgs = collateInterpolationArgs(strings, expressions);
     return callVariadicInstruction(CLASS_MAP_INTERPOLATE_CONFIG, [], interpolationArgs, [], sourceSpan);
 }
-function hostProperty(name, expression, sanitizer, sourceSpan) {
+function domProperty(name, expression, sanitizer, sourceSpan) {
     const args = [literal(name), expression];
     if (sanitizer !== null) {
         args.push(sanitizer);
     }
-    return call(Identifiers.hostProperty, args, sourceSpan);
+    return call(Identifiers.domProperty, args, sourceSpan);
 }
 function syntheticHostProperty(name, expression, sourceSpan) {
     return call(Identifiers.syntheticHostProperty, [literal(name), expression], sourceSpan);
@@ -23415,6 +23526,26 @@ function reifyCreateOperations(unit, ops) {
                 }
                 OpList.replace(op, projection(op.handle.slot, op.projectionSlotIndex, op.attributes, fallbackViewFnName, fallbackDecls, fallbackVars, op.sourceSpan));
                 break;
+            case OpKind.ConditionalCreate:
+                if (!(unit instanceof ViewCompilationUnit)) {
+                    throw new Error(`AssertionError: must be compiling a component`);
+                }
+                if (Array.isArray(op.localRefs)) {
+                    throw new Error(`AssertionError: local refs array should have been extracted into a constant`);
+                }
+                const conditionalCreateChildView = unit.job.views.get(op.xref);
+                OpList.replace(op, conditionalCreate(op.handle.slot, variable(conditionalCreateChildView.fnName), conditionalCreateChildView.decls, conditionalCreateChildView.vars, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
+                break;
+            case OpKind.ConditionalBranchCreate:
+                if (!(unit instanceof ViewCompilationUnit)) {
+                    throw new Error(`AssertionError: must be compiling a component`);
+                }
+                if (Array.isArray(op.localRefs)) {
+                    throw new Error(`AssertionError: local refs array should have been extracted into a constant`);
+                }
+                const conditionalBranchCreateChildView = unit.job.views.get(op.xref);
+                OpList.replace(op, conditionalBranchCreate(op.handle.slot, variable(conditionalBranchCreateChildView.fnName), conditionalBranchCreateChildView.decls, conditionalBranchCreateChildView.vars, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
+                break;
             case OpKind.RepeaterCreate:
                 if (op.handle.slot === null) {
                     throw new Error('No slot was assigned for repeater instruction');
@@ -23527,7 +23658,7 @@ function reifyUpdateOperations(_unit, ops) {
                     OpList.replace(op, attribute(op.name, op.expression, op.sanitizer, op.namespace));
                 }
                 break;
-            case OpKind.HostProperty:
+            case OpKind.DomProperty:
                 if (op.expression instanceof Interpolation) {
                     throw new Error('not yet handled');
                 }
@@ -23536,7 +23667,7 @@ function reifyUpdateOperations(_unit, ops) {
                         OpList.replace(op, syntheticHostProperty(op.name, op.expression, op.sourceSpan));
                     }
                     else {
-                        OpList.replace(op, hostProperty(op.name, op.expression, op.sanitizer, op.sourceSpan));
+                        OpList.replace(op, domProperty(op.name, op.expression, op.sanitizer, op.sourceSpan));
                     }
                 }
                 break;
@@ -23972,6 +24103,8 @@ function resolvePlaceholdersForView(job, unit, i18nContexts, elements, pendingSt
                     pendingStructuralDirective = undefined;
                 }
                 break;
+            case OpKind.ConditionalCreate:
+            case OpKind.ConditionalBranchCreate:
             case OpKind.Template:
                 const view = job.views.get(op.xref);
                 if (op.i18nPlaceholder === undefined) {
@@ -24368,7 +24501,7 @@ function resolveSanitizers(job) {
             switch (op.kind) {
                 case OpKind.Property:
                 case OpKind.Attribute:
-                case OpKind.HostProperty:
+                case OpKind.DomProperty:
                     let sanitizerFn = null;
                     if (Array.isArray(op.securityContext) &&
                         op.securityContext.length === 2 &&
@@ -24390,7 +24523,7 @@ function resolveSanitizers(job) {
                     // <iframe>).
                     if (op.sanitizer === null) {
                         let isIframe = false;
-                        if (job.kind === CompilationJobKind.Host || op.kind === OpKind.HostProperty) {
+                        if (job.kind === CompilationJobKind.Host || op.kind === OpKind.DomProperty) {
                             // Note: for host bindings defined on a directive, we do not try to find all
                             // possible places where it can be matched, so we can not determine whether
                             // the host element is an <iframe>. In this case, we just assume it is and append a
@@ -24535,7 +24668,10 @@ function allocateSlots(job) {
     // propagate the number of slots used for each view into the operation which declares it.
     for (const unit of job.units) {
         for (const op of unit.ops()) {
-            if (op.kind === OpKind.Template || op.kind === OpKind.RepeaterCreate) {
+            if (op.kind === OpKind.Template ||
+                op.kind === OpKind.ConditionalCreate ||
+                op.kind === OpKind.ConditionalBranchCreate ||
+                op.kind === OpKind.RepeaterCreate) {
                 // Record the number of slots used by the view this `ir.TemplateOp` declares in the
                 // operation itself, so it can be emitted later.
                 const childView = job.views.get(op.xref);
@@ -24596,6 +24732,8 @@ function optimizeStoreLet(job) {
  *    typescript AST, the parentheses node is removed, and then the remaining AST is printed, it
  *    incorrectly prints `a ? b : c ?? d`. This is different from how it handles the same situation
  *    with `||` and `&&` where it prints the parentheses even if they are not present in the AST.
+ *    Note: We may be able to remove this case if Typescript resolves the following issue:
+ *    https://github.com/microsoft/TypeScript/issues/61369
  */
 function stripNonrequiredParentheses(job) {
     // Check which parentheses are required.
@@ -24970,7 +25108,10 @@ function countVariables(job) {
         // an embedded view).
         for (const unit of job.units) {
             for (const op of unit.create) {
-                if (op.kind !== OpKind.Template && op.kind !== OpKind.RepeaterCreate) {
+                if (op.kind !== OpKind.Template &&
+                    op.kind !== OpKind.RepeaterCreate &&
+                    op.kind !== OpKind.ConditionalCreate &&
+                    op.kind !== OpKind.ConditionalBranchCreate) {
                     continue;
                 }
                 const childView = job.views.get(op.xref);
@@ -24989,7 +25130,7 @@ function varsUsedByOp(op) {
     let slots;
     switch (op.kind) {
         case OpKind.Property:
-        case OpKind.HostProperty:
+        case OpKind.DomProperty:
         case OpKind.Attribute:
             // All of these bindings use 1 variable slot, plus 1 slot for every interpolated expression,
             // if any.
@@ -25718,7 +25859,7 @@ function ingestHostBinding(input, bindingParser, constantPool) {
         const securityContexts = bindingParser
             .calcPossibleSecurityContexts(input.componentSelector, property.name, bindingKind === BindingKind.Attribute)
             .filter((context) => context !== SecurityContext.NONE);
-        ingestHostProperty(job, property, bindingKind, securityContexts);
+        ingestDomProperty(job, property, bindingKind, securityContexts);
     }
     for (const [name, expr] of Object.entries(input.attributes) ?? []) {
         const securityContexts = bindingParser
@@ -25733,7 +25874,7 @@ function ingestHostBinding(input, bindingParser, constantPool) {
 }
 // TODO: We should refactor the parser to use the same types and structures for host bindings as
 // with ordinary components. This would allow us to share a lot more ingestion code.
-function ingestHostProperty(job, property, bindingKind, securityContexts) {
+function ingestDomProperty(job, property, bindingKind, securityContexts) {
     let expression;
     const ast = property.expression.ast;
     if (ast instanceof Interpolation$1) {
@@ -25954,13 +26095,14 @@ function ingestIfBlock(unit, ifBlock) {
             }
             ifCaseI18nMeta = ifCase.i18n;
         }
-        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, 'Conditional', Namespace.HTML, ifCaseI18nMeta, ifCase.startSourceSpan, ifCase.sourceSpan);
-        unit.create.push(templateOp);
+        const createOp = i === 0 ? createConditionalCreateOp : createConditionalBranchCreateOp;
+        const conditionalCreateOp = createOp(cView.xref, TemplateKind.Block, tagName, 'Conditional', Namespace.HTML, ifCaseI18nMeta, ifCase.startSourceSpan, ifCase.sourceSpan);
+        unit.create.push(conditionalCreateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
         }
         const caseExpr = ifCase.expression ? convertAst(ifCase.expression, unit.job, null) : null;
-        const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, templateOp.xref, templateOp.handle, ifCase.expressionAlias);
+        const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, conditionalCreateOp.xref, conditionalCreateOp.handle, ifCase.expressionAlias);
         conditions.push(conditionalCaseExpr);
         ingestNodes(cView, ifCase.children);
     }
@@ -25976,7 +26118,8 @@ function ingestSwitchBlock(unit, switchBlock) {
     }
     let firstXref = null;
     let conditions = [];
-    for (const switchCase of switchBlock.cases) {
+    for (let i = 0; i < switchBlock.cases.length; i++) {
+        const switchCase = switchBlock.cases[i];
         const cView = unit.job.allocateView(unit.xref);
         const tagName = ingestControlFlowInsertionPoint(unit, cView.xref, switchCase);
         let switchCaseI18nMeta = undefined;
@@ -25986,15 +26129,16 @@ function ingestSwitchBlock(unit, switchBlock) {
             }
             switchCaseI18nMeta = switchCase.i18n;
         }
-        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, 'Case', Namespace.HTML, switchCaseI18nMeta, switchCase.startSourceSpan, switchCase.sourceSpan);
-        unit.create.push(templateOp);
+        const createOp = i === 0 ? createConditionalCreateOp : createConditionalBranchCreateOp;
+        const conditionalCreateOp = createOp(cView.xref, TemplateKind.Block, tagName, 'Case', Namespace.HTML, switchCaseI18nMeta, switchCase.startSourceSpan, switchCase.sourceSpan);
+        unit.create.push(conditionalCreateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
         }
         const caseExpr = switchCase.expression
             ? convertAst(switchCase.expression, unit.job, switchBlock.startSourceSpan)
             : null;
-        const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, templateOp.xref, templateOp.handle);
+        const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, conditionalCreateOp.xref, conditionalCreateOp.handle);
         conditions.push(conditionalCaseExpr);
         ingestNodes(cView, switchCase.children);
     }
@@ -27248,10 +27392,16 @@ class BindingParser {
         const prop = this._schemaRegistry.getMappedPropName(propName);
         return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
     }
+    parseEventListenerName(rawName) {
+        const [target, eventName] = splitAtColon(rawName, [null, rawName]);
+        return { eventName: eventName, target };
+    }
+    parseAnimationEventName(rawName) {
+        const matches = splitAtPeriod(rawName, [rawName, null]);
+        return { eventName: matches[0], phase: matches[1] === null ? null : matches[1].toLowerCase() };
+    }
     _parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
-        const matches = splitAtPeriod(name, [name, '']);
-        const eventName = matches[0];
-        const phase = matches[1].toLowerCase();
+        const { eventName, phase } = this.parseAnimationEventName(name);
         const ast = this._parseAction(expression, handlerSpan);
         targetEvents.push(new ParsedEvent(eventName, phase, ParsedEventType.Animation, ast, sourceSpan, handlerSpan, keySpan));
         if (eventName.length === 0) {
@@ -27268,7 +27418,7 @@ class BindingParser {
     }
     _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
         // long format: 'target: eventName'
-        const [target, eventName] = splitAtColon(name, [null, name]);
+        const { eventName, target } = this.parseEventListenerName(name);
         const prevErrorCount = this.errors.length;
         const ast = this._parseAction(expression, handlerSpan);
         const isValid = this.errors.length === prevErrorCount;
@@ -27472,11 +27622,13 @@ const FOR_LOOP_EXPRESSION_PATTERN = /^\s*([0-9A-Za-z_$]*)\s+of\s+([\S\s]*)/;
 /** Pattern for the tracking expression in a for loop block. */
 const FOR_LOOP_TRACK_PATTERN = /^track\s+([\S\s]*)/;
 /** Pattern for the `as` expression in a conditional block. */
-const CONDITIONAL_ALIAS_PATTERN = /^(as\s)+(.*)/;
+const CONDITIONAL_ALIAS_PATTERN = /^(as\s+)(.*)/;
 /** Pattern used to identify an `else if` block. */
 const ELSE_IF_PATTERN = /^else[^\S\r\n]+if/;
 /** Pattern used to identify a `let` parameter. */
 const FOR_LOOP_LET_PATTERN = /^let\s+([\S\s]*)/;
+/** Pattern used to validate a JavaScript identifier. */
+const IDENTIFIER_PATTERN = /^[$A-Z_][0-9A-Z_$]*$/i;
 /**
  * Pattern to group a string into leading whitespace, non whitespace, and trailing whitespace.
  * Useful for getting the variable name span when a span can contain leading and trailing space.
@@ -27824,9 +27976,14 @@ function parseConditionalBlockParameters(block, errors, bindingParser) {
         }
         else {
             const name = aliasMatch[2].trim();
-            const variableStart = param.sourceSpan.start.moveBy(aliasMatch[1].length);
-            const variableSpan = new ParseSourceSpan(variableStart, variableStart.moveBy(name.length));
-            expressionAlias = new Variable(name, name, variableSpan, variableSpan);
+            if (IDENTIFIER_PATTERN.test(name)) {
+                const variableStart = param.sourceSpan.start.moveBy(aliasMatch[1].length);
+                const variableSpan = new ParseSourceSpan(variableStart, variableStart.moveBy(name.length));
+                expressionAlias = new Variable(name, name, variableSpan, variableSpan);
+            }
+            else {
+                errors.push(new ParseError(param.sourceSpan, '"as" expression must be a valid JavaScript identifier'));
+            }
         }
     }
     return { expression, expressionAlias };
@@ -32911,7 +33068,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -32929,7 +33086,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? literal(null));
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', literal('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -33024,7 +33181,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -33440,7 +33597,7 @@ 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('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -33475,7 +33632,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -33526,7 +33683,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -33559,7 +33716,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -33610,7 +33767,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('20.0.0-next.3'));
+    definitionMap.set('version', literal('20.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -33768,7 +33925,7 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('20.0.0-next.3');
+const VERSION = new Version('20.0.0-next.5');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //