@angular/compiler 17.0.0-next.6 → 17.0.0-next.8

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.6
+ * @license Angular v17.0.0-next.8
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2482,6 +2482,7 @@ class Identifiers {
     static { this.deferPrefetchOnHover = { name: 'ɵɵdeferPrefetchOnHover', moduleName: CORE }; }
     static { this.deferPrefetchOnInteraction = { name: 'ɵɵdeferPrefetchOnInteraction', moduleName: CORE }; }
     static { this.deferPrefetchOnViewport = { name: 'ɵɵdeferPrefetchOnViewport', moduleName: CORE }; }
+    static { this.deferEnableTimerScheduling = { name: 'ɵɵdeferEnableTimerScheduling', moduleName: CORE }; }
     static { this.conditional = { name: 'ɵɵconditional', moduleName: CORE }; }
     static { this.repeater = { name: 'ɵɵrepeater', moduleName: CORE }; }
     static { this.repeaterCreate = { name: 'ɵɵrepeaterCreate', moduleName: CORE }; }
@@ -2605,6 +2606,7 @@ class Identifiers {
     static { this.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE }; }
     static { this.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE }; }
     static { this.setClassMetadataAsync = { name: 'ɵsetClassMetadataAsync', moduleName: CORE }; }
+    static { this.setClassDebugInfo = { name: 'ɵsetClassDebugInfo', moduleName: CORE }; }
     static { this.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE }; }
     static { this.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE }; }
     static { this.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE }; }
@@ -3139,7 +3141,14 @@ class AbstractEmitterVisitor {
         return null;
     }
     visitInvokeFunctionExpr(expr, ctx) {
+        const shouldParenthesize = expr.fn instanceof ArrowFunctionExpr;
+        if (shouldParenthesize) {
+            ctx.print(expr.fn, '(');
+        }
         expr.fn.visitExpression(this, ctx);
+        if (shouldParenthesize) {
+            ctx.print(expr.fn, ')');
+        }
         ctx.print(expr, `(`);
         this.visitAllExpressions(expr.args, ctx, ',');
         ctx.print(expr, `)`);
@@ -3438,7 +3447,7 @@ function wrapReference(value) {
 }
 function refsToArray(refs, shouldForwardDeclare) {
     const values = literalArr(refs.map(ref => ref.value));
-    return shouldForwardDeclare ? fn([], [new ReturnStatement(values)]) : values;
+    return shouldForwardDeclare ? arrowFn([], values) : values;
 }
 function createMayBeForwardRefExpression(expression, forwardRef) {
     return { expression, forwardRef };
@@ -3471,7 +3480,7 @@ function convertFromMaybeForwardRefExpression({ expression, forwardRef }) {
  * ```
  */
 function generateForwardRef(expr) {
-    return importExpr(Identifiers.forwardRef).callFn([fn([], [new ReturnStatement(expr)])]);
+    return importExpr(Identifiers.forwardRef).callFn([arrowFn([], expr)]);
 }
 
 var R3FactoryDelegateType;
@@ -3559,7 +3568,7 @@ function compileFactoryFunction(meta) {
     if (baseFactoryVar !== null) {
         // There is a base factory variable so wrap its declaration along with the factory function into
         // an IIFE.
-        factoryFn = fn([], [
+        factoryFn = arrowFn([], [
             new DeclareVarStmt(baseFactoryVar.name), new ReturnStatement(factoryFn)
         ]).callFn([], /* sourceSpan */ undefined, /* pure */ true);
     }
@@ -3861,12 +3870,13 @@ class DeferredBlockError {
     }
 }
 class DeferredBlock {
-    constructor(children, triggers, prefetchTriggers, placeholder, loading, error, sourceSpan, startSourceSpan, endSourceSpan) {
+    constructor(children, triggers, prefetchTriggers, placeholder, loading, error, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan) {
         this.children = children;
         this.placeholder = placeholder;
         this.loading = loading;
         this.error = error;
         this.sourceSpan = sourceSpan;
+        this.mainBlockSpan = mainBlockSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
         this.triggers = triggers;
@@ -3883,20 +3893,23 @@ class DeferredBlock {
         this.visitTriggers(this.definedTriggers, this.triggers, visitor);
         this.visitTriggers(this.definedPrefetchTriggers, this.prefetchTriggers, visitor);
         visitAll$1(visitor, this.children);
-        this.placeholder && visitor.visitDeferredBlockPlaceholder(this.placeholder);
-        this.loading && visitor.visitDeferredBlockLoading(this.loading);
-        this.error && visitor.visitDeferredBlockError(this.error);
+        const remainingBlocks = [this.placeholder, this.loading, this.error].filter(x => x !== null);
+        visitAll$1(visitor, remainingBlocks);
     }
     visitTriggers(keys, triggers, visitor) {
-        for (const key of keys) {
-            visitor.visitDeferredTrigger(triggers[key]);
-        }
+        visitAll$1(visitor, keys.map(k => triggers[k]));
     }
 }
 class SwitchBlock {
-    constructor(expression, cases, sourceSpan, startSourceSpan, endSourceSpan) {
+    constructor(expression, cases, 
+    /**
+     * These blocks are only captured to allow for autocompletion in the language service. They
+     * aren't meant to be processed in any other way.
+     */
+    unknownBlocks, sourceSpan, startSourceSpan, endSourceSpan) {
         this.expression = expression;
         this.cases = cases;
+        this.unknownBlocks = unknownBlocks;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
@@ -3906,18 +3919,19 @@ class SwitchBlock {
     }
 }
 class SwitchBlockCase {
-    constructor(expression, children, sourceSpan, startSourceSpan) {
+    constructor(expression, children, sourceSpan, startSourceSpan, endSourceSpan) {
         this.expression = expression;
         this.children = children;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
     }
     visit(visitor) {
         return visitor.visitSwitchBlockCase(this);
     }
 }
 class ForLoopBlock {
-    constructor(item, expression, trackBy, contextVariables, children, empty, sourceSpan, startSourceSpan, endSourceSpan) {
+    constructor(item, expression, trackBy, contextVariables, children, empty, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan) {
         this.item = item;
         this.expression = expression;
         this.trackBy = trackBy;
@@ -3925,6 +3939,7 @@ class ForLoopBlock {
         this.children = children;
         this.empty = empty;
         this.sourceSpan = sourceSpan;
+        this.mainBlockSpan = mainBlockSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
     }
@@ -3933,10 +3948,11 @@ class ForLoopBlock {
     }
 }
 class ForLoopBlockEmpty {
-    constructor(children, sourceSpan, startSourceSpan) {
+    constructor(children, sourceSpan, startSourceSpan, endSourceSpan) {
         this.children = children;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
     }
     visit(visitor) {
         return visitor.visitForLoopBlockEmpty(this);
@@ -3954,17 +3970,27 @@ class IfBlock {
     }
 }
 class IfBlockBranch {
-    constructor(expression, children, expressionAlias, sourceSpan, startSourceSpan) {
+    constructor(expression, children, expressionAlias, sourceSpan, startSourceSpan, endSourceSpan) {
         this.expression = expression;
         this.children = children;
         this.expressionAlias = expressionAlias;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
     }
     visit(visitor) {
         return visitor.visitIfBlockBranch(this);
     }
 }
+class UnknownBlock {
+    constructor(name, sourceSpan) {
+        this.name = name;
+        this.sourceSpan = sourceSpan;
+    }
+    visit(visitor) {
+        return visitor.visitUnknownBlock(this);
+    }
+}
 class Template {
     constructor(
     // tagName is the name of the container element, if applicable.
@@ -4071,10 +4097,9 @@ class RecursiveVisitor$1 {
         visitAll$1(this, block.children);
     }
     visitForLoopBlock(block) {
-        block.item.visit(this);
-        visitAll$1(this, Object.values(block.contextVariables));
-        visitAll$1(this, block.children);
-        block.empty?.visit(this);
+        const blockItems = [block.item, ...Object.values(block.contextVariables), ...block.children];
+        block.empty && blockItems.push(block.empty);
+        visitAll$1(this, blockItems);
     }
     visitForLoopBlockEmpty(block) {
         visitAll$1(this, block.children);
@@ -4083,8 +4108,9 @@ class RecursiveVisitor$1 {
         visitAll$1(this, block.branches);
     }
     visitIfBlockBranch(block) {
-        visitAll$1(this, block.children);
-        block.expressionAlias?.visit(this);
+        const blockItems = block.children;
+        block.expressionAlias && blockItems.push(block.expressionAlias);
+        visitAll$1(this, blockItems);
     }
     visitContent(content) { }
     visitVariable(variable) { }
@@ -4096,6 +4122,7 @@ class RecursiveVisitor$1 {
     visitBoundText(text) { }
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
+    visitUnknownBlock(block) { }
 }
 function visitAll$1(visitor, nodes) {
     const result = [];
@@ -4931,7 +4958,13 @@ class DefinitionMap {
     }
     set(key, value) {
         if (value) {
-            this.values.push({ key: key, value, quoted: false });
+            const existing = this.values.find(value => value.key === key);
+            if (existing) {
+                existing.value = value;
+            }
+            else {
+                this.values.push({ key: key, value, quoted: false });
+            }
         }
     }
     toLiteralMap() {
@@ -5074,10 +5107,7 @@ function compileInjectable(meta, resolveForwardRefs) {
             });
         }
         else {
-            result = {
-                statements: [],
-                expression: fn([], [new ReturnStatement(meta.useFactory.callFn([]))])
-            };
+            result = { statements: [], expression: arrowFn([], meta.useFactory.callFn([])) };
         }
     }
     else if (meta.useValue !== undefined) {
@@ -5146,7 +5176,7 @@ function delegateToFactory(type, useType, unwrapForwardRefs) {
     return createFactoryFunction(unwrappedType);
 }
 function createFactoryFunction(type) {
-    return fn([new FnParam('t', DYNAMIC_TYPE)], [new ReturnStatement(type.prop('ɵfac').callFn([variable('t')]))]);
+    return arrowFn([new FnParam('t', DYNAMIC_TYPE)], type.prop('ɵfac').callFn([variable('t')]));
 }
 
 const UNUSABLE_INTERPOLATION_REGEXPS = [
@@ -8759,38 +8789,58 @@ var OpKind;
      * An attribute that has been extracted for inclusion in the consts array.
      */
     OpKind[OpKind["ExtractedAttribute"] = 25] = "ExtractedAttribute";
+    /**
+     * An operation that configures a `@defer` block.
+     */
+    OpKind[OpKind["Defer"] = 26] = "Defer";
+    /**
+     * An IR operation that provides secondary templates of a `@defer` block.
+     */
+    OpKind[OpKind["DeferSecondaryBlock"] = 27] = "DeferSecondaryBlock";
+    /**
+     * An operation that controls when a `@defer` loads.
+     */
+    OpKind[OpKind["DeferOn"] = 28] = "DeferOn";
     /**
      * An i18n message that has been extracted for inclusion in the consts array.
      */
-    OpKind[OpKind["ExtractedMessage"] = 26] = "ExtractedMessage";
+    OpKind[OpKind["ExtractedMessage"] = 29] = "ExtractedMessage";
     /**
      * A host binding property.
      */
-    OpKind[OpKind["HostProperty"] = 27] = "HostProperty";
+    OpKind[OpKind["HostProperty"] = 30] = "HostProperty";
     /**
      * A namespace change, which causes the subsequent elements to be processed as either HTML or SVG.
      */
-    OpKind[OpKind["Namespace"] = 28] = "Namespace";
+    OpKind[OpKind["Namespace"] = 31] = "Namespace";
     /**
      * Configure a content projeciton definition for the view.
      */
-    OpKind[OpKind["ProjectionDef"] = 29] = "ProjectionDef";
+    OpKind[OpKind["ProjectionDef"] = 32] = "ProjectionDef";
     /**
      * Create a content projection slot.
      */
-    OpKind[OpKind["Projection"] = 30] = "Projection";
+    OpKind[OpKind["Projection"] = 33] = "Projection";
     /**
      * The start of an i18n block.
      */
-    OpKind[OpKind["I18nStart"] = 31] = "I18nStart";
+    OpKind[OpKind["I18nStart"] = 34] = "I18nStart";
     /**
      * A self-closing i18n on a single element.
      */
-    OpKind[OpKind["I18n"] = 32] = "I18n";
+    OpKind[OpKind["I18n"] = 35] = "I18n";
     /**
      * The end of an i18n block.
      */
-    OpKind[OpKind["I18nEnd"] = 33] = "I18nEnd";
+    OpKind[OpKind["I18nEnd"] = 36] = "I18nEnd";
+    /**
+     * An expression in an i18n message.
+     */
+    OpKind[OpKind["I18nExpression"] = 37] = "I18nExpression";
+    /**
+     * An instruction that applies a set of i18n expressions.
+     */
+    OpKind[OpKind["I18nApply"] = 38] = "I18nApply";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -8881,6 +8931,10 @@ var ExpressionKind;
      * An expression that will cause a literal slot index to be emitted.
      */
     ExpressionKind[ExpressionKind["SlotLiteralExpr"] = 20] = "SlotLiteralExpr";
+    /**
+     * A test expression for a conditional op.
+     */
+    ExpressionKind[ExpressionKind["ConditionalCase"] = 21] = "ConditionalCase";
 })(ExpressionKind || (ExpressionKind = {}));
 /**
  * Distinguishes between different kinds of `SemanticVariable`s.
@@ -8922,6 +8976,15 @@ var SanitizerFn;
     SanitizerFn[SanitizerFn["ResourceUrl"] = 4] = "ResourceUrl";
     SanitizerFn[SanitizerFn["IframeAttribute"] = 5] = "IframeAttribute";
 })(SanitizerFn || (SanitizerFn = {}));
+/**
+ * Enumeration of the different kinds of `@defer` secondary blocks.
+ */
+var DeferSecondaryKind;
+(function (DeferSecondaryKind) {
+    DeferSecondaryKind[DeferSecondaryKind["Loading"] = 0] = "Loading";
+    DeferSecondaryKind[DeferSecondaryKind["Placeholder"] = 1] = "Placeholder";
+    DeferSecondaryKind[DeferSecondaryKind["Error"] = 2] = "Error";
+})(DeferSecondaryKind || (DeferSecondaryKind = {}));
 /**
  * Enumeration of the types of attributes which can be applied to an element.
  */
@@ -8977,6 +9040,10 @@ const ConsumesVarsTrait = Symbol('ConsumesVars');
  * Marker symbol for `UsesVarOffset` trait.
  */
 const UsesVarOffset = Symbol('UsesVarOffset');
+/**
+ * Marker symbol for `HasConst` trait.
+ */
+const HasConst = Symbol('HasConst');
 /**
  * Default values for most `ConsumesSlotOpTrait` fields (used with the spread operator to initialize
  * implementors of the trait).
@@ -8992,7 +9059,7 @@ const TRAIT_CONSUMES_SLOT = {
  */
 const TRAIT_USES_SLOT_INDEX = {
     [UsesSlotIndex]: true,
-    slot: null,
+    targetSlot: null,
 };
 /**
  * Default values for most `DependsOnSlotContextOpTrait` fields (used with the spread operator to
@@ -9016,6 +9083,14 @@ const TRAIT_USES_VAR_OFFSET = {
     [UsesVarOffset]: true,
     varOffset: null,
 };
+/**
+ * Default values for `HasConst` fields (used with the spread operator to initialize
+ * implementors of this trait).
+ */
+const TRAIT_HAS_CONST = {
+    [HasConst]: true,
+    constIndex: null,
+};
 /**
  * Test whether an operation implements `ConsumesSlotOpTrait`.
  */
@@ -9040,6 +9115,9 @@ function hasUsesVarOffsetTrait(expr) {
 function hasUsesSlotIndexTrait(value) {
     return value[UsesSlotIndex] === true;
 }
+function hasConstTrait(value) {
+    return value[HasConst] === true;
+}
 
 /**
  * Create a `StatementOp`.
@@ -9078,11 +9156,12 @@ const NEW_OP = {
 /**
  * Create an `InterpolationTextOp`.
  */
-function createInterpolateTextOp(xref, interpolation, sourceSpan) {
+function createInterpolateTextOp(xref, interpolation, i18nPlaceholders, sourceSpan) {
     return {
         kind: OpKind.InterpolateText,
         target: xref,
         interpolation,
+        i18nPlaceholders,
         sourceSpan,
         ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
         ...TRAIT_CONSUMES_VARS,
@@ -9220,17 +9299,47 @@ function createAdvanceOp(delta, sourceSpan) {
 /**
  * Create a conditional op, which will display an embedded view according to a condtion.
  */
-function createConditionalOp(target, test, sourceSpan) {
+function createConditionalOp(target, test, conditions, sourceSpan) {
     return {
         kind: OpKind.Conditional,
         target,
         test,
-        conditions: [],
+        conditions,
         processed: null,
         sourceSpan,
+        contextValue: null,
         ...NEW_OP,
         ...TRAIT_USES_SLOT_INDEX,
         ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+    };
+}
+/**
+ * Create an i18n expression op.
+ */
+function createI18nExpressionOp(owner, expression, i18nPlaceholder, sourceSpan) {
+    return {
+        kind: OpKind.I18nExpression,
+        owner,
+        target: owner,
+        expression,
+        i18nPlaceholder,
+        sourceSpan,
+        ...NEW_OP,
+        ...TRAIT_CONSUMES_VARS,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+    };
+}
+/**
+ * Creates an op to apply i18n expression ops.
+ */
+function createI18nApplyOp(target, sourceSpan) {
+    return {
+        kind: OpKind.I18nApply,
+        target,
+        sourceSpan,
+        ...NEW_OP,
+        ...TRAIT_USES_SLOT_INDEX,
     };
 }
 
@@ -9281,7 +9390,7 @@ class ReferenceExpr extends ExpressionBase {
         this.offset = offset;
         this.kind = ExpressionKind.Reference;
         this[_a] = true;
-        this.slot = null;
+        this.targetSlot = null;
     }
     visitExpression() { }
     isEquivalent(e) {
@@ -9293,7 +9402,7 @@ class ReferenceExpr extends ExpressionBase {
     transformInternalExpressions() { }
     clone() {
         const expr = new ReferenceExpr(this.target, this.offset);
-        expr.slot = this.slot;
+        expr.targetSlot = this.targetSlot;
         return expr;
     }
 }
@@ -9530,7 +9639,7 @@ class PipeBindingExpr extends ExpressionBase {
         this[_d] = true;
         this[_e] = true;
         this[_f] = true;
-        this.slot = null;
+        this.targetSlot = null;
         this.varOffset = null;
     }
     visitExpression(visitor, context) {
@@ -9551,7 +9660,7 @@ class PipeBindingExpr extends ExpressionBase {
     }
     clone() {
         const r = new PipeBindingExpr(this.target, this.name, this.args.map(a => a.clone()));
-        r.slot = this.slot;
+        r.targetSlot = this.targetSlot;
         r.varOffset = this.varOffset;
         return r;
     }
@@ -9568,7 +9677,7 @@ class PipeBindingVariadicExpr extends ExpressionBase {
         this[_g] = true;
         this[_h] = true;
         this[_j] = true;
-        this.slot = null;
+        this.targetSlot = null;
         this.varOffset = null;
     }
     visitExpression(visitor, context) {
@@ -9585,7 +9694,7 @@ class PipeBindingVariadicExpr extends ExpressionBase {
     }
     clone() {
         const r = new PipeBindingVariadicExpr(this.target, this.name, this.args.clone(), this.numArgs);
-        r.slot = this.slot;
+        r.targetSlot = this.targetSlot;
         r.varOffset = this.varOffset;
         return r;
     }
@@ -9785,20 +9894,56 @@ class SlotLiteralExpr extends ExpressionBase {
         this.target = target;
         this.kind = ExpressionKind.SlotLiteralExpr;
         this[_k] = true;
-        this.slot = null;
+        this.targetSlot = null;
     }
     visitExpression(visitor, context) { }
     isEquivalent(e) {
-        return e instanceof SlotLiteralExpr && e.target === this.target && e.slot === this.slot;
+        return e instanceof SlotLiteralExpr && e.target === this.target &&
+            e.targetSlot === this.targetSlot;
     }
     isConstant() {
         return true;
     }
     clone() {
-        return new SlotLiteralExpr(this.target);
+        const copy = new SlotLiteralExpr(this.target);
+        copy.targetSlot = this.targetSlot;
+        return copy;
     }
     transformInternalExpressions() { }
 }
+class ConditionalCaseExpr extends ExpressionBase {
+    /**
+     * Create an expression for one branch of a conditional.
+     * @param expr The expression to be tested for this case. Might be null, as in an `else` case.
+     * @param target The Xref of the view to be displayed if this condition is true.
+     */
+    constructor(expr, target, alias = null) {
+        super();
+        this.expr = expr;
+        this.target = target;
+        this.alias = alias;
+        this.kind = ExpressionKind.ConditionalCase;
+    }
+    visitExpression(visitor, context) {
+        if (this.expr !== null) {
+            this.expr.visitExpression(visitor, context);
+        }
+    }
+    isEquivalent(e) {
+        return e instanceof ConditionalCaseExpr && e.expr === this.expr;
+    }
+    isConstant() {
+        return true;
+    }
+    clone() {
+        return new ConditionalCaseExpr(this.expr, this.target);
+    }
+    transformInternalExpressions(transform, flags) {
+        if (this.expr !== null) {
+            this.expr = transformExpressionsInExpression(this.expr, transform, flags);
+        }
+    }
+}
 /**
  * Visits all `Expression`s in the AST of `op` with the `visitor` function.
  */
@@ -9851,6 +9996,9 @@ function transformExpressionsInOp(op, transform, flags) {
             op.sanitizer =
                 op.sanitizer && transformExpressionsInExpression(op.sanitizer, transform, flags);
             break;
+        case OpKind.I18nExpression:
+            op.expression = transformExpressionsInExpression(op.expression, transform, flags);
+            break;
         case OpKind.InterpolateText:
             transformExpressionsInInterpolation(op.interpolation, transform, flags);
             break;
@@ -9862,15 +10010,18 @@ function transformExpressionsInOp(op, transform, flags) {
             break;
         case OpKind.Conditional:
             for (const condition of op.conditions) {
-                if (condition[1] === null) {
+                if (condition.expr === null) {
                     // This is a default case.
                     continue;
                 }
-                condition[1] = transformExpressionsInExpression(condition[1], transform, flags);
+                condition.expr = transformExpressionsInExpression(condition.expr, transform, flags);
             }
             if (op.processed !== null) {
                 op.processed = transformExpressionsInExpression(op.processed, transform, flags);
             }
+            if (op.contextValue !== null) {
+                op.contextValue = transformExpressionsInExpression(op.contextValue, transform, flags);
+            }
             break;
         case OpKind.Listener:
             for (const innerOp of op.handlerOps) {
@@ -9887,18 +10038,20 @@ function transformExpressionsInOp(op, transform, flags) {
                 transformExpressionsInStatement(statement, transform, flags);
             }
             break;
+        case OpKind.I18n:
         case OpKind.I18nStart:
-            for (const placeholder in op.tagNameParams) {
-                op.tagNameParams[placeholder] =
-                    transformExpressionsInExpression(op.tagNameParams[placeholder], transform, flags);
+            for (const [placeholder, expression] of op.params) {
+                op.params.set(placeholder, transformExpressionsInExpression(expression, transform, flags));
             }
             break;
+        case OpKind.Defer:
+        case OpKind.DeferSecondaryBlock:
+        case OpKind.DeferOn:
         case OpKind.Projection:
         case OpKind.ProjectionDef:
         case OpKind.Element:
         case OpKind.ElementStart:
         case OpKind.ElementEnd:
-        case OpKind.I18n:
         case OpKind.I18nEnd:
         case OpKind.Container:
         case OpKind.ContainerStart:
@@ -9910,6 +10063,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Pipe:
         case OpKind.Advance:
         case OpKind.Namespace:
+        case OpKind.I18nApply:
             // These operations contain no expressions.
             break;
         default:
@@ -10190,7 +10344,7 @@ class OpList {
         // Replace `oldOp` with the chain `first` -> `last`.
         if (oldPrev !== null) {
             oldPrev.next = first;
-            first.prev = oldOp.prev;
+            first.prev = oldPrev;
         }
         if (oldNext !== null) {
             oldNext.prev = last;
@@ -10297,7 +10451,7 @@ function isElementOrContainerOp(op) {
 /**
  * Create an `ElementStartOp`.
  */
-function createElementStartOp(tag, xref, namespace, i18n, sourceSpan) {
+function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan) {
     return {
         kind: OpKind.ElementStart,
         xref,
@@ -10306,7 +10460,7 @@ function createElementStartOp(tag, xref, namespace, i18n, sourceSpan) {
         localRefs: [],
         nonBindable: false,
         namespace,
-        i18n,
+        i18nPlaceholder,
         sourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
@@ -10315,19 +10469,19 @@ function createElementStartOp(tag, xref, namespace, i18n, sourceSpan) {
 /**
  * Create a `TemplateOp`.
  */
-function createTemplateOp(xref, tag, namespace, controlFlow, i18n, sourceSpan) {
+function createTemplateOp(xref, tag, namespace, generatedInBlock, i18nPlaceholder, sourceSpan) {
     return {
         kind: OpKind.Template,
         xref,
         attributes: null,
         tag,
-        controlFlow,
+        block: generatedInBlock,
         decls: null,
         vars: null,
         localRefs: [],
         nonBindable: false,
         namespace,
-        i18n,
+        i18nPlaceholder,
         sourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
@@ -10432,11 +10586,9 @@ function createProjectionOp(xref, selector) {
         attributes: null,
         localRefs: [],
         nonBindable: false,
-        i18n: undefined,
         sourceSpan: null,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
-        ...TRAIT_USES_SLOT_INDEX,
     };
 }
 /**
@@ -10452,6 +10604,42 @@ function createExtractedAttributeOp(target, bindingKind, name, expression) {
         ...NEW_OP,
     };
 }
+function createDeferOp(xref, main, sourceSpan) {
+    return {
+        kind: OpKind.Defer,
+        xref,
+        target: main,
+        loading: null,
+        placeholder: null,
+        error: null,
+        sourceSpan,
+        ...NEW_OP,
+        ...TRAIT_CONSUMES_SLOT,
+        ...TRAIT_USES_SLOT_INDEX,
+    };
+}
+function createDeferSecondaryOp(deferOp, secondaryView, secondaryBlockKind) {
+    return {
+        kind: OpKind.DeferSecondaryBlock,
+        deferOp,
+        target: secondaryView,
+        secondaryBlockKind,
+        constValue: null,
+        makeExpression: literalOrArrayLiteral$1,
+        ...NEW_OP,
+        ...TRAIT_USES_SLOT_INDEX,
+        ...TRAIT_HAS_CONST,
+    };
+}
+function createDeferOnOp(xref, sourceSpan) {
+    return {
+        kind: OpKind.DeferOn,
+        xref,
+        sourceSpan,
+        ...NEW_OP,
+        ...TRAIT_CONSUMES_SLOT,
+    };
+}
 /**
  * Create an `ExtractedMessageOp`.
  */
@@ -10467,13 +10655,15 @@ function createExtractedMessageOp(owner, expression, statements) {
 /**
  * Create an `I18nStartOp`.
  */
-function createI18nStartOp(xref, i18n) {
+function createI18nStartOp(xref, message, root) {
     return {
         kind: OpKind.I18nStart,
         xref,
-        i18n,
-        tagNameParams: {},
+        root: root ?? xref,
+        message,
+        params: new Map(),
         messageIndex: null,
+        subTemplateIndex: null,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -10488,6 +10678,12 @@ function createI18nEndOp(xref) {
         ...NEW_OP,
     };
 }
+function literalOrArrayLiteral$1(value) {
+    if (Array.isArray(value)) {
+        return literalArr(value.map(literalOrArrayLiteral$1));
+    }
+    return literal(value, INFERRED_TYPE);
+}
 
 function createHostPropertyOp(name, expression, isAnimationTrigger, sourceSpan) {
     return {
@@ -10501,6 +10697,12 @@ function createHostPropertyOp(name, expression, isAnimationTrigger, sourceSpan)
     };
 }
 
+/**
+ * When referenced in the template's context parameters, this indicates a reference to the entire
+ * context object, rather than a specific parameter.
+ */
+const CTX_REF = 'CTX_REF_MARKER';
+
 var CompilationJobKind;
 (function (CompilationJobKind) {
     CompilationJobKind[CompilationJobKind["Tmpl"] = 0] = "Tmpl";
@@ -10688,10 +10890,16 @@ function phaseVarCounting(job) {
     // First, count the vars used in each view, and update the view-level counter.
     for (const unit of job.units) {
         let varCount = 0;
+        // Count variables on top-level ops first. Don't explore nested expressions just yet.
         for (const op of unit.ops()) {
             if (hasConsumesVarsTrait(op)) {
                 varCount += varsUsedByOp(op);
             }
+        }
+        // Count variables on expressions inside ops. We do this later because some of these expressions
+        // might be conditional (e.g. `pipeBinding` inside of a ternary), and we don't want to interfere
+        // with indices for top-level binding slots (e.g. `property`).
+        for (const op of unit.ops()) {
             visitExpressionsInOp(op, expr => {
                 if (!isIrExpression(expr)) {
                     return;
@@ -10752,6 +10960,9 @@ function varsUsedByOp(op) {
         case OpKind.InterpolateText:
             // `ir.InterpolateTextOp`s use a variable slot for each dynamic expression.
             return op.interpolation.expressions.length;
+        case OpKind.I18nExpression:
+        case OpKind.Conditional:
+            return 1;
         default:
             throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
     }
@@ -10823,6 +11034,60 @@ function removeAnys(e) {
     return e;
 }
 
+/**
+ * Adds apply operations after i18n expressions.
+ */
+function phaseApplyI18nExpressions(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            // Only add apply after expressions that are not followed by more expressions.
+            if (op.kind === OpKind.I18nExpression && needsApplication(op)) {
+                // TODO: what should be the source span for the apply op?
+                OpList.insertAfter(createI18nApplyOp(op.owner, null), op);
+            }
+        }
+    }
+}
+/**
+ * Checks whether the given expression op needs to be followed with an apply op.
+ */
+function needsApplication(op) {
+    // If the next op is not another expression, we need to apply.
+    if (op.next?.kind !== OpKind.I18nExpression) {
+        return true;
+    }
+    // If the next op is an expression targeting a different i18n block, we need to apply.
+    if (op.next.owner !== op.owner) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Updates i18n expression ops to depend on the last slot in their owning i18n block.
+ */
+function phaseAssignI18nSlotDependencies(job) {
+    const i18nLastSlotConsumers = new Map();
+    let lastSlotConsumer = null;
+    for (const unit of job.units) {
+        // Record the last consumed slot before each i18n end instruction.
+        for (const op of unit.create) {
+            if (op.kind === OpKind.I18nEnd) {
+                i18nLastSlotConsumers.set(op.xref, lastSlotConsumer);
+            }
+            if (hasConsumesSlotTrait(op)) {
+                lastSlotConsumer = op.xref;
+            }
+        }
+        // Assign i18n expressions to target the last slot in its owning block.
+        for (const op of unit.update) {
+            if (op.kind === OpKind.I18nExpression) {
+                op.target = i18nLastSlotConsumers.get(op.owner);
+            }
+        }
+    }
+}
+
 /**
  * Gets a map of all elements in the given view by their xref id.
  */
@@ -10984,14 +11249,20 @@ function phaseBindingSpecialization(job) {
 }
 
 const CHAINABLE = new Set([
-    Identifiers.elementStart,
-    Identifiers.elementEnd,
+    Identifiers.attribute,
+    Identifiers.classProp,
     Identifiers.element,
-    Identifiers.property,
+    Identifiers.elementContainer,
+    Identifiers.elementContainerEnd,
+    Identifiers.elementContainerStart,
+    Identifiers.elementEnd,
+    Identifiers.elementStart,
     Identifiers.hostProperty,
-    Identifiers.syntheticHostProperty,
+    Identifiers.i18nExp,
+    Identifiers.listener,
+    Identifiers.listener,
+    Identifiers.property,
     Identifiers.styleProp,
-    Identifiers.attribute,
     Identifiers.stylePropInterpolate1,
     Identifiers.stylePropInterpolate2,
     Identifiers.stylePropInterpolate3,
@@ -11001,13 +11272,8 @@ const CHAINABLE = new Set([
     Identifiers.stylePropInterpolate7,
     Identifiers.stylePropInterpolate8,
     Identifiers.stylePropInterpolateV,
-    Identifiers.classProp,
-    Identifiers.listener,
-    Identifiers.elementContainerStart,
-    Identifiers.elementContainerEnd,
-    Identifiers.elementContainer,
-    Identifiers.listener,
     Identifiers.syntheticHostListener,
+    Identifiers.syntheticHostProperty,
     Identifiers.templateCreate,
 ]);
 /**
@@ -11084,9 +11350,9 @@ function phaseConditionals(job) {
             }
             let test;
             // Any case with a `null` condition is `default`. If one exists, default to it instead.
-            const defaultCase = op.conditions.findIndex(([xref, cond]) => cond === null);
+            const defaultCase = op.conditions.findIndex((cond) => cond.expr === null);
             if (defaultCase >= 0) {
-                const [xref, cond] = op.conditions.splice(defaultCase, 1)[0];
+                const xref = op.conditions.splice(defaultCase, 1)[0].target;
                 test = new SlotLiteralExpr(xref);
             }
             else {
@@ -11094,13 +11360,26 @@ function phaseConditionals(job) {
                 test = literal(-1);
             }
             // Switch expressions assign their main test to a temporary, to avoid re-executing it.
-            let tmp = new AssignTemporaryExpr(op.test, job.allocateXrefId());
-            // For each remaining condition, test whether the temporary satifies the check.
+            let tmp = op.test == null ? null : new AssignTemporaryExpr(op.test, job.allocateXrefId());
+            // For each remaining condition, test whether the temporary satifies the check. (If no temp is
+            // present, just check each expression directly.)
             for (let i = op.conditions.length - 1; i >= 0; i--) {
-                const useTmp = i === 0 ? tmp : new ReadTemporaryExpr(tmp.xref);
-                const [xref, check] = op.conditions[i];
-                const comparison = new BinaryOperatorExpr(BinaryOperator.Identical, useTmp, check);
-                test = new ConditionalExpr(comparison, new SlotLiteralExpr(xref), test);
+                let conditionalCase = op.conditions[i];
+                if (conditionalCase.expr === null) {
+                    continue;
+                }
+                if (tmp !== null) {
+                    const useTmp = i === 0 ? tmp : new ReadTemporaryExpr(tmp.xref);
+                    conditionalCase.expr =
+                        new BinaryOperatorExpr(BinaryOperator.Identical, useTmp, conditionalCase.expr);
+                }
+                else if (conditionalCase.alias !== null) {
+                    const caseExpressionTemporaryXref = job.allocateXrefId();
+                    conditionalCase.expr =
+                        new AssignTemporaryExpr(conditionalCase.expr, caseExpressionTemporaryXref);
+                    op.contextValue = new ReadTemporaryExpr(caseExpressionTemporaryXref);
+                }
+                test = new ConditionalExpr(conditionalCase.expr, new SlotLiteralExpr(conditionalCase.target), test);
             }
             // Save the resulting aggregate Joost-expression.
             op.processed = test;
@@ -11162,14 +11441,15 @@ const BINARY_OPERATORS = new Map([
     ['||', BinaryOperator.Or],
     ['+', BinaryOperator.Plus],
 ]);
-const NAMESPACES = new Map([['svg', Namespace.SVG], ['math', Namespace.Math]]);
 function namespaceForKey(namespacePrefixKey) {
+    const NAMESPACES = new Map([['svg', Namespace.SVG], ['math', Namespace.Math]]);
     if (namespacePrefixKey === null) {
         return Namespace.HTML;
     }
     return NAMESPACES.get(namespacePrefixKey) ?? Namespace.HTML;
 }
 function keyForNamespace(namespace) {
+    const NAMESPACES = new Map([['svg', Namespace.SVG], ['math', Namespace.Math]]);
     for (const [k, n] of NAMESPACES.entries()) {
         if (n === namespace) {
             return k;
@@ -11345,6 +11625,10 @@ const REPLACEMENTS = new Map([
     [OpKind.ContainerEnd, [OpKind.ContainerStart, OpKind.Container]],
     [OpKind.I18nEnd, [OpKind.I18nStart, OpKind.I18n]],
 ]);
+/**
+ * Op kinds that should not prevent merging of start/end ops.
+ */
+const IGNORED_OP_KINDS = new Set([OpKind.Pipe]);
 /**
  * Replace sequences of mergable elements (e.g. `ElementStart` and `ElementEnd`) with a consolidated
  * element (e.g. `Element`).
@@ -11352,15 +11636,22 @@ const REPLACEMENTS = new Map([
 function phaseEmptyElements(job) {
     for (const unit of job.units) {
         for (const op of unit.create) {
+            // Find end ops that may be able to be merged.
             const opReplacements = REPLACEMENTS.get(op.kind);
             if (opReplacements === undefined) {
                 continue;
             }
             const [startKind, mergedKind] = opReplacements;
-            if (op.prev !== null && op.prev.kind === startKind) {
+            // Locate the previous (non-ignored) op.
+            let prevOp = op.prev;
+            while (prevOp !== null && IGNORED_OP_KINDS.has(prevOp.kind)) {
+                prevOp = prevOp.prev;
+            }
+            // If the previous op is the corresponding start op, we can megre.
+            if (prevOp !== null && prevOp.kind === startKind) {
                 // Transmute the start instruction to the merged version. This is safe as they're designed
                 // to be identical apart from the `kind`.
-                op.prev.kind = mergedKind;
+                prevOp.kind = mergedKind;
                 // Remove the end instruction.
                 OpList.remove(op);
             }
@@ -11592,31 +11883,39 @@ function phaseGenerateAdvance(job) {
 }
 
 /**
- * Generate i18n start and end isntructions to mark i18n blocks.
+ * Locate projection slots, populate the each component's `ngContentSelectors` literal field,
+ * populate `project` arguments, and generate the required `projectionDef` instruction for the job's
+ * root view.
  */
-function phaseGenerateI18nBlocks(job) {
+function phaseGenerateProjectionDef(job) {
+    // TODO: Why does TemplateDefinitionBuilder force a shared constant?
+    const share = job.compatibility === CompatibilityMode.TemplateDefinitionBuilder;
+    // Collect all selectors from this component, and its nested views. Also, assign each projection a
+    // unique ascending projection slot index.
+    const selectors = [];
+    let projectionSlotIndex = 0;
     for (const unit of job.units) {
-        const elements = getElementsByXrefId(unit);
         for (const op of unit.create) {
-            switch (op.kind) {
-                case OpKind.ElementEnd:
-                    const start = elements.get(op.xref);
-                    if (start.i18n instanceof Message) {
-                        const id = job.allocateXrefId();
-                        OpList.insertAfter(createI18nStartOp(id, start.i18n), start);
-                        OpList.insertBefore(createI18nEndOp(id), op);
-                    }
-                    break;
-                case OpKind.Template:
-                    if (op.i18n !== undefined) {
-                        const id = job.allocateXrefId();
-                        OpList.insertBefore(createI18nStartOp(id, op.i18n), op);
-                        OpList.insertAfter(createI18nEndOp(id), op);
-                    }
-                    break;
+            if (op.kind === OpKind.Projection) {
+                selectors.push(op.selector);
+                op.projectionSlotIndex = projectionSlotIndex++;
             }
         }
     }
+    if (selectors.length > 0) {
+        // Create the projectionDef array. If we only found a single wildcard selector, then we use the
+        // default behavior with no arguments instead.
+        let defExpr = null;
+        if (selectors.length > 1 || selectors[0] !== '*') {
+            const def = selectors.map(s => s === '*' ? s : parseSelectorToR3Selector(s));
+            defExpr = job.pool.getConstLiteral(literalOrArrayLiteral(def), share);
+        }
+        // Create the ngContentSelectors constant.
+        job.contentSelectors = job.pool.getConstLiteral(literalOrArrayLiteral(selectors), share);
+        // The projection def instruction goes at the beginning of the root view, before any
+        // `projection` instructions.
+        job.root.create.prepend([createProjectionDefOp(defExpr)]);
+    }
 }
 
 /**
@@ -11727,7 +12026,11 @@ function generateVariablesInScopeForView(view, scope) {
     }
     // Add variables for all context variables available in this scope's view.
     for (const [name, value] of view.job.views.get(scope.view).contextVariables) {
-        newOps.push(createVariableOp(view.job.allocateXrefId(), scope.contextVariables.get(name), new ReadPropExpr(new ContextExpr(scope.view), value)));
+        const context = new ContextExpr(scope.view);
+        // We either read the context, or, if the variable is CTX_REF, use the context directly.
+        const variable = value === CTX_REF ? context : new ReadPropExpr(context, value);
+        // Add the variable declaration.
+        newOps.push(createVariableOp(view.job.allocateXrefId(), scope.contextVariables.get(name), variable));
     }
     // Add variables for all local references declared for elements in this scope.
     for (const ref of scope.references) {
@@ -11740,15 +12043,46 @@ function generateVariablesInScopeForView(view, scope) {
     return newOps;
 }
 
+/**
+ * Looks for the HasConst trait, indicating that an op or expression has some data which
+ * should be collected into the constant array. Capable of collecting either a single literal value,
+ * or an array literal.
+ */
+function phaseConstTraitCollection(job) {
+    const collectGlobalConsts = (e) => {
+        if (e instanceof ExpressionBase && hasConstTrait(e)) {
+            // TODO: Figure out how to make this type narrowing work.
+            const ea = e;
+            if (ea.constValue !== null) {
+                ea.constIndex = job.addConst(ea.constValue);
+            }
+        }
+        return e;
+    };
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            if (hasConstTrait(op) && op.constValue !== null) {
+                op.constIndex = job.addConst(op.makeExpression(op.constValue));
+            }
+            transformExpressionsInOp(op, collectGlobalConsts, VisitorContextFlag.None);
+        }
+    }
+}
+
 const STYLE_DOT = 'style.';
 const CLASS_DOT = 'class.';
 const STYLE_BANG = 'style!';
 const CLASS_BANG = 'class!';
+const BANG_IMPORTANT = '!important';
 function phaseHostStylePropertyParsing(job) {
     for (const op of job.root.update) {
         if (op.kind !== OpKind.Binding) {
             continue;
         }
+        if (op.name.endsWith(BANG_IMPORTANT)) {
+            // Delete any `!important` suffixes from the binding name.
+            op.name = op.name.substring(0, op.name.length - BANG_IMPORTANT.length);
+        }
         if (op.name.startsWith(STYLE_DOT)) {
             op.bindingKind = BindingKind.StyleProperty;
             op.name = op.name.substring(STYLE_DOT.length);
@@ -11802,6 +12136,31 @@ function parseProperty$1(name) {
     return { property, suffix };
 }
 
+/**
+ * Lifts i18n properties into the consts array.
+ */
+function phaseI18nConstCollection(job) {
+    // Serialize the extracted messages into the const array.
+    // TODO: Use `Map` instead of object.
+    const messageConstIndices = {};
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.ExtractedMessage) {
+                messageConstIndices[op.owner] = job.addConst(op.expression, op.statements);
+                OpList.remove(op);
+            }
+        }
+    }
+    // Assign const index to i18n ops that messages were extracted from.
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.I18nStart || op.kind === OpKind.I18n) {
+                op.messageIndex = messageConstIndices[op.root];
+            }
+        }
+    }
+}
+
 function mapEntry(key, value) {
     return { key, value, quoted: false };
 }
@@ -16691,7 +17050,7 @@ class _Tokenizer {
             new PlainCharacterCursor(_file, range);
         this._preserveLineEndings = options.preserveLineEndings || false;
         this._i18nNormalizeLineEndingsInICUs = options.i18nNormalizeLineEndingsInICUs || false;
-        this._tokenizeBlocks = options.tokenizeBlocks || false;
+        this._tokenizeBlocks = options.tokenizeBlocks ?? true;
         try {
             this._cursor.init();
         }
@@ -16749,7 +17108,7 @@ class _Tokenizer {
                 this.handleError(e);
             }
         }
-        this._beginToken(28 /* TokenType.EOF */);
+        this._beginToken(29 /* TokenType.EOF */);
         this._endToken([]);
     }
     _getBlockName() {
@@ -16770,7 +17129,7 @@ class _Tokenizer {
     }
     _consumeBlockStart(start) {
         this._beginToken(24 /* TokenType.BLOCK_OPEN_START */, start);
-        this._endToken([this._getBlockName()]);
+        const startToken = this._endToken([this._getBlockName()]);
         if (this._cursor.peek() === $LPAREN) {
             // Advance past the opening paren.
             this._cursor.advance();
@@ -16778,14 +17137,22 @@ class _Tokenizer {
             this._consumeBlockParameters();
             // Allow spaces before the closing paren.
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            // Skip over the closing paren.
-            this._requireCharCode($RPAREN);
-            // Allow spaces after the paren.
-            this._attemptCharCodeUntilFn(isNotWhitespace);
+            if (this._attemptCharCode($RPAREN)) {
+                // Allow spaces after the paren.
+                this._attemptCharCodeUntilFn(isNotWhitespace);
+            }
+            else {
+                startToken.type = 28 /* TokenType.INCOMPLETE_BLOCK_OPEN */;
+                return;
+            }
+        }
+        if (this._attemptCharCode($LBRACE)) {
+            this._beginToken(25 /* TokenType.BLOCK_OPEN_END */);
+            this._endToken([]);
+        }
+        else {
+            startToken.type = 28 /* TokenType.INCOMPLETE_BLOCK_OPEN */;
         }
-        this._beginToken(25 /* TokenType.BLOCK_OPEN_END */);
-        this._requireCharCode($LBRACE);
-        this._endToken([]);
     }
     _consumeBlockEnd(start) {
         this._beginToken(26 /* TokenType.BLOCK_CLOSE */, start);
@@ -17758,7 +18125,7 @@ class _TreeBuilder {
         this._advance();
     }
     build() {
-        while (this._peek.type !== 28 /* TokenType.EOF */) {
+        while (this._peek.type !== 29 /* TokenType.EOF */) {
             if (this._peek.type === 0 /* TokenType.TAG_OPEN_START */ ||
                 this._peek.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
                 this._consumeStartTag(this._advance());
@@ -17790,6 +18157,10 @@ class _TreeBuilder {
                 this._closeVoidElement();
                 this._consumeBlockClose(this._advance());
             }
+            else if (this._peek.type === 28 /* TokenType.INCOMPLETE_BLOCK_OPEN */) {
+                this._closeVoidElement();
+                this._consumeIncompleteBlock(this._advance());
+            }
             else {
                 // Skip all other tokens...
                 this._advance();
@@ -17863,7 +18234,7 @@ class _TreeBuilder {
         if (!exp)
             return null;
         const end = this._advance();
-        exp.push({ type: 28 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
+        exp.push({ type: 29 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
         // parse everything in between { and }
         const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
         expansionCaseParser.build();
@@ -17903,7 +18274,7 @@ class _TreeBuilder {
                     return null;
                 }
             }
-            if (this._peek.type === 28 /* TokenType.EOF */) {
+            if (this._peek.type === 29 /* TokenType.EOF */) {
                 this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
                 return null;
             }
@@ -18105,16 +18476,30 @@ class _TreeBuilder {
         const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
         const block = new Block(token.parts[0], parameters, [], span, startSpan);
         this._pushContainer(block, false);
-        return block;
     }
     _consumeBlockClose(token) {
-        const previousContainer = this._getContainer();
         if (!this._popContainer(null, Block, token.sourceSpan)) {
-            const context = previousContainer instanceof Element ?
-                `There is an unclosed "${previousContainer.name}" HTML tag that may have to be closed first.` :
-                `The block may have been closed earlier.`;
-            this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. ${context}`));
+            this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. The block may have been closed earlier. ` +
+                `If you meant to write the } character, you should use the "}" ` +
+                `HTML entity instead.`));
+        }
+    }
+    _consumeIncompleteBlock(token) {
+        const parameters = [];
+        while (this._peek.type === 27 /* TokenType.BLOCK_PARAMETER */) {
+            const paramToken = this._advance();
+            parameters.push(new BlockParameter(paramToken.parts[0], paramToken.sourceSpan));
         }
+        const end = this._peek.sourceSpan.fullStart;
+        const span = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+        // Create a separate `startSpan` because `span` will be modified when there is an `end` span.
+        const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+        const block = new Block(token.parts[0], parameters, [], span, startSpan);
+        this._pushContainer(block, false);
+        // Incomplete blocks don't have children so we close them immediately and report an error.
+        this._popContainer(null, Block, null);
+        this.errors.push(TreeError.create(token.parts[0], span, `Incomplete block "${token.parts[0]}". If you meant to write the @ character, ` +
+            `you should use the "@" HTML entity instead.`));
     }
     _getContainer() {
         return this._containerStack.length > 0 ? this._containerStack[this._containerStack.length - 1] :
@@ -18668,17 +19053,20 @@ function phaseI18nMessageExtraction(job) {
     const fileBasedI18nSuffix = job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_').toUpperCase() + '_';
     for (const unit of job.units) {
         for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart && op.i18n instanceof Message) {
-                // Sort the params map to match the ordering in TemplateDefinitionBuilder.
-                const params = Object.fromEntries(Object.entries(op.tagNameParams).sort());
-                const mainVar = variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));
-                // Closure Compiler requires const names to start with `MSG_` but disallows any other const
-                // to start with `MSG_`. We define a variable starting with `MSG_` just for the
-                // `goog.getMsg` call
-                const closureVar = i18nGenerateClosureVar(job.pool, op.i18n.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
-                // TODO: figure out transformFn.
-                const statements = getTranslationDeclStmts$1(op.i18n, mainVar, closureVar, params, undefined /*transformFn*/);
-                unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
+            if ((op.kind === OpKind.I18nStart || op.kind === OpKind.I18n)) {
+                // Only extract messages from root i18n ops, not sub-template ones.
+                if (op.xref === op.root) {
+                    // Sort the params map to match the ordering in TemplateDefinitionBuilder.
+                    const params = new Map([...op.params.entries()].sort());
+                    const mainVar = variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));
+                    // Closure Compiler requires const names to start with `MSG_` but disallows any other
+                    // const to start with `MSG_`. We define a variable starting with `MSG_` just for the
+                    // `goog.getMsg` call
+                    const closureVar = i18nGenerateClosureVar(job.pool, op.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
+                    // TODO: figure out transformFn.
+                    const statements = getTranslationDeclStmts$1(op.message, mainVar, closureVar, params, undefined /*transformFn*/);
+                    unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
+                }
             }
         }
     }
@@ -18709,10 +19097,11 @@ function phaseI18nMessageExtraction(job) {
  * post-processing).
  * @returns An array of statements that defined a given translation.
  */
-function getTranslationDeclStmts$1(message, variable, closureVar, params = {}, transformFn) {
+function getTranslationDeclStmts$1(message, variable, closureVar, params, transformFn) {
+    const paramsObject = Object.fromEntries(params);
     const statements = [
         declareI18nVariable(variable),
-        ifStmt(createClosureModeGuard$1(), createGoogleGetMsgStatements(variable, message, closureVar, params), createLocalizeStatements(variable, message, formatI18nPlaceholderNamesInMap(params, /* useCamelCase */ false))),
+        ifStmt(createClosureModeGuard$1(), createGoogleGetMsgStatements(variable, message, closureVar, paramsObject), createLocalizeStatements(variable, message, formatI18nPlaceholderNamesInMap(paramsObject, /* useCamelCase */ false))),
     ];
     if (transformFn) {
         statements.push(new ExpressionStatement(variable.set(transformFn(variable))));
@@ -18755,22 +19144,48 @@ function i18nGenerateClosureVar(pool, messageId, fileBasedI18nSuffix, useExterna
  */
 function phaseI18nTextExtraction(job) {
     for (const unit of job.units) {
-        let inI18nBlock = false;
+        // Remove all text nodes within i18n blocks, their content is already captured in the i18n
+        // message.
+        let currentI18nId = null;
+        const textNodes = new Map();
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
-                    inI18nBlock = true;
+                    currentI18nId = op.xref;
                     break;
                 case OpKind.I18nEnd:
-                    inI18nBlock = false;
+                    currentI18nId = null;
                     break;
                 case OpKind.Text:
-                    if (inI18nBlock) {
+                    if (currentI18nId !== null) {
+                        textNodes.set(op.xref, currentI18nId);
                         OpList.remove(op);
                     }
                     break;
             }
         }
+        // Update any interpolations to the removed text, and instead represent them as a series of i18n
+        // expressions that we then apply.
+        for (const op of unit.update) {
+            switch (op.kind) {
+                case OpKind.InterpolateText:
+                    if (!textNodes.has(op.target)) {
+                        continue;
+                    }
+                    const i18nBlockId = textNodes.get(op.target);
+                    const ops = [];
+                    for (let i = 0; i < op.interpolation.expressions.length; i++) {
+                        const expr = op.interpolation.expressions[i];
+                        const placeholder = op.i18nPlaceholders[i];
+                        ops.push(createI18nExpressionOp(i18nBlockId, expr, placeholder, expr.sourceSpan ?? op.sourceSpan));
+                    }
+                    if (ops.length > 0) {
+                        // ops.push(ir.createI18nApplyOp(i18nBlockId, op.i18nPlaceholders, op.sourceSpan));
+                    }
+                    OpList.replaceWithMany(op, ops);
+                    break;
+            }
+        }
     }
 }
 
@@ -18934,7 +19349,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
                 if (op.handlerFnName !== null) {
                     break;
                 }
-                if (!op.hostListener && op.slot === null) {
+                if (!op.hostListener && op.targetSlot === null) {
                     throw new Error(`Expected a slot to be assigned`);
                 }
                 let animation = '';
@@ -18946,7 +19361,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
                     op.handlerFnName = `${baseName}_${animation}${op.name}_HostBindingHandler`;
                 }
                 else {
-                    op.handlerFnName = `${unit.fnName}_${op.tag.replace('-', '_')}_${animation}${op.name}_${op.slot}_listener`;
+                    op.handlerFnName = `${unit.fnName}_${op.tag.replace('-', '_')}_${animation}${op.name}_${op.targetSlot}_listener`;
                 }
                 op.handlerFnName = sanitizeIdentifier(op.handlerFnName);
                 break;
@@ -19095,6 +19510,11 @@ function phaseNgContainer(job) {
     for (const unit of job.units) {
         const updatedElementXrefs = new Set();
         for (const op of unit.create) {
+            if (op.kind === OpKind.Element && op.tag === CONTAINER_TAG) {
+                // Transmute the `Element` instruction to `Container`.
+                op.kind = OpKind.Container;
+                updatedElementXrefs.add(op.xref);
+            }
             if (op.kind === OpKind.ElementStart && op.tag === CONTAINER_TAG) {
                 // Transmute the `ElementStart` instruction to `ContainerStart`.
                 op.kind = OpKind.ContainerStart;
@@ -19108,30 +19528,6 @@ function phaseNgContainer(job) {
     }
 }
 
-function phaseNoListenersOnTemplates(job) {
-    for (const unit of job.units) {
-        let inTemplate = false;
-        for (const op of unit.create) {
-            switch (op.kind) {
-                case OpKind.Template:
-                    inTemplate = true;
-                    break;
-                case OpKind.ElementStart:
-                case OpKind.Element:
-                case OpKind.ContainerStart:
-                case OpKind.Container:
-                    inTemplate = false;
-                    break;
-                case OpKind.Listener:
-                    if (inTemplate) {
-                        OpList.remove(op);
-                    }
-                    break;
-            }
-        }
-    }
-}
-
 /**
  * Looks up an element in the given map by xref ID.
  */
@@ -19189,6 +19585,95 @@ function phaseNullishCoalescing(job) {
     }
 }
 
+function kindTest(kind) {
+    return (op) => op.kind === kind;
+}
+/**
+ * Defines the groups based on `OpKind` that ops will be divided into, for the various create
+ * binding kinds. Ops will be collected into groups, then optionally transformed, before recombining
+ * the groups in the order defined here.
+ */
+const CREATE_ORDERING = [
+    { test: op => op.kind === OpKind.Listener && op.hostListener && op.isAnimationListener },
+    { test: op => op.kind === OpKind.Listener && !(op.hostListener && op.isAnimationListener) },
+];
+/**
+ * As above, but for update ops.
+ */
+const UPDATE_ORDERING = [
+    { test: op => op.kind === OpKind.HostProperty && op.expression instanceof Interpolation },
+    { test: op => op.kind === OpKind.HostProperty && !(op.expression instanceof Interpolation) },
+    { test: kindTest(OpKind.StyleMap), transform: keepLast },
+    { test: kindTest(OpKind.ClassMap), transform: keepLast },
+    { test: kindTest(OpKind.StyleProp) },
+    { test: kindTest(OpKind.ClassProp) },
+    { test: op => op.kind === OpKind.Property && op.expression instanceof Interpolation },
+    { test: op => op.kind === OpKind.Property && !(op.expression instanceof Interpolation) },
+    { test: kindTest(OpKind.Attribute) },
+];
+/**
+ * The set of all op kinds we handle in the reordering phase.
+ */
+const handledOpKinds = new Set([
+    OpKind.Listener, OpKind.StyleMap, OpKind.ClassMap, OpKind.StyleProp,
+    OpKind.ClassProp, OpKind.Property, OpKind.HostProperty, OpKind.Attribute
+]);
+function phaseOrdering(job) {
+    for (const unit of job.units) {
+        // First, we pull out ops that need to be ordered. Then, when we encounter an op that shouldn't
+        // be reordered, put the ones we've pulled so far back in the correct order. Finally, if we
+        // still have ops pulled at the end, put them back in the correct order.
+        // Create mode:
+        let opsToOrder = [];
+        for (const op of unit.create) {
+            if (handledOpKinds.has(op.kind)) {
+                opsToOrder.push(op);
+                OpList.remove(op);
+            }
+            else {
+                OpList.insertBefore(reorder(opsToOrder, CREATE_ORDERING), op);
+                opsToOrder = [];
+            }
+        }
+        unit.create.push(reorder(opsToOrder, CREATE_ORDERING));
+        // Update mode:
+        opsToOrder = [];
+        for (const op of unit.update) {
+            if (handledOpKinds.has(op.kind)) {
+                opsToOrder.push(op);
+                OpList.remove(op);
+            }
+            else {
+                OpList.insertBefore(reorder(opsToOrder, UPDATE_ORDERING), op);
+                opsToOrder = [];
+            }
+        }
+        unit.update.push(reorder(opsToOrder, UPDATE_ORDERING));
+    }
+}
+/**
+ * Reorders the given list of ops according to the ordering defined by `ORDERING`.
+ */
+function reorder(ops, ordering) {
+    // Break the ops list into groups based on OpKind.
+    const groups = Array.from(ordering, () => new Array());
+    for (const op of ops) {
+        const groupIndex = ordering.findIndex(o => o.test(op));
+        groups[groupIndex].push(op);
+    }
+    // Reassemble the groups into a single list, in the correct order.
+    return groups.flatMap((group, i) => {
+        const transform = ordering[i].transform;
+        return transform ? transform(group) : group;
+    });
+}
+/**
+ * Keeps only the last op in a list of ops.
+ */
+function keepLast(ops) {
+    return ops.slice(ops.length - 1);
+}
+
 /**
  * Parses extracted style and class attributes into separate ExtractedAttributeOps per style or
  * class property.
@@ -19217,6 +19702,36 @@ function phaseParseExtractedStyles(cpl) {
     }
 }
 
+/**
+ * Attributes of `ng-content` named 'select' are specifically removed, because they control which
+ * content matches as a property of the `projection`, and are not a plain attribute.
+ */
+function phaseRemoveContentSelectors(job) {
+    for (const unit of job.units) {
+        const elements = getElementsByXrefId(unit);
+        for (const op of unit.update) {
+            switch (op.kind) {
+                case OpKind.Binding:
+                    const target = lookupElement(elements, op.target);
+                    if (op.name.toLowerCase() === 'select' && target.kind === OpKind.Projection) {
+                        OpList.remove(op);
+                    }
+                    continue;
+            }
+        }
+    }
+}
+/**
+ * Looks up an element in the given map by xref ID.
+ */
+function lookupElement(elements, xref) {
+    const el = elements.get(xref);
+    if (el === undefined) {
+        throw new Error('All attributes should have an element-like target.');
+    }
+    return el;
+}
+
 function phasePipeCreation(job) {
     for (const unit of job.units) {
         processPipeBindingsInView(unit);
@@ -19283,93 +19798,84 @@ function phasePipeVariadic(job) {
     }
 }
 
-function kindTest(kind) {
-    return (op) => op.kind === kind;
-}
 /**
- * Defines the groups based on `OpKind` that ops will be divided into, for the various create
- * binding kinds. Ops will be collected into groups, then optionally transformed, before recombining
- * the groups in the order defined here.
+ * Propagate i18n blocks down through child templates that act as placeholders in the root i18n
+ * message.
  */
-const CREATE_ORDERING = [
-    { test: op => op.kind === OpKind.Listener && op.hostListener && op.isAnimationListener },
-    { test: op => op.kind === OpKind.Listener && !(op.hostListener && op.isAnimationListener) },
-];
+function phasePropagateI18nBlocks(job) {
+    propagateI18nBlocksToTemplates(job.root, 0);
+}
 /**
- * As above, but for update ops.
+ * Propagates i18n ops in the given view through to any child views recursively.
  */
-const UPDATE_ORDERING = [
-    { test: op => op.kind === OpKind.HostProperty && op.expression instanceof Interpolation },
-    { test: op => op.kind === OpKind.HostProperty && !(op.expression instanceof Interpolation) },
-    { test: kindTest(OpKind.StyleMap), transform: keepLast },
-    { test: kindTest(OpKind.ClassMap), transform: keepLast },
-    { test: kindTest(OpKind.StyleProp) },
-    { test: kindTest(OpKind.ClassProp) },
-    { test: op => op.kind === OpKind.Property && op.expression instanceof Interpolation },
-    { test: op => op.kind === OpKind.Property && !(op.expression instanceof Interpolation) },
-    { test: kindTest(OpKind.Attribute) },
-];
+function propagateI18nBlocksToTemplates(unit, subTemplateIndex) {
+    let i18nBlock = null;
+    for (const op of unit.create) {
+        switch (op.kind) {
+            case OpKind.I18nStart:
+                op.subTemplateIndex = subTemplateIndex === 0 ? null : subTemplateIndex;
+                i18nBlock = op;
+                break;
+            case OpKind.I18nEnd:
+                i18nBlock = null;
+                break;
+            case OpKind.Template:
+                const templateView = unit.job.views.get(op.xref);
+                // We found an <ng-template> inside an i18n block; increment the sub-template counter and
+                // wrap the template's view in a child i18n block.
+                if (op.i18nPlaceholder !== undefined) {
+                    if (i18nBlock === null) {
+                        throw Error('Expected template with i18n placeholder to be in an i18n block.');
+                    }
+                    subTemplateIndex++;
+                    wrapTemplateWithI18n(templateView, i18nBlock);
+                }
+                // Continue traversing inside the template's view.
+                propagateI18nBlocksToTemplates(templateView, subTemplateIndex);
+        }
+    }
+}
 /**
- * The set of all op kinds we handle in the reordering phase.
+ * Wraps a template view with i18n start and end ops.
  */
-const handledOpKinds = new Set([
-    OpKind.Listener, OpKind.StyleMap, OpKind.ClassMap, OpKind.StyleProp,
-    OpKind.ClassProp, OpKind.Property, OpKind.HostProperty, OpKind.Attribute
-]);
-function phaseOrdering(job) {
+function wrapTemplateWithI18n(unit, parentI18n) {
+    // Only add i18n ops if they have not already been propagated to this template.
+    if (unit.create.head.next?.kind !== OpKind.I18nStart) {
+        const id = unit.job.allocateXrefId();
+        OpList.insertAfter(createI18nStartOp(id, parentI18n.message, parentI18n.root), unit.create.head);
+        OpList.insertBefore(createI18nEndOp(id), unit.create.tail);
+    }
+}
+
+function phasePropagateI18nPlaceholders(job) {
+    // Get all of the i18n ops.
+    const i18nOps = new Map();
     for (const unit of job.units) {
-        // First, we pull out ops that need to be ordered. Then, when we encounter an op that shouldn't
-        // be reordered, put the ones we've pulled so far back in the correct order. Finally, if we
-        // still have ops pulled at the end, put them back in the correct order.
-        // Create mode:
-        let opsToOrder = [];
         for (const op of unit.create) {
-            if (handledOpKinds.has(op.kind)) {
-                opsToOrder.push(op);
-                OpList.remove(op);
-            }
-            else {
-                OpList.insertBefore(reorder(opsToOrder, CREATE_ORDERING), op);
-                opsToOrder = [];
+            if (op.kind === OpKind.I18nStart) {
+                i18nOps.set(op.xref, op);
             }
         }
-        unit.create.push(reorder(opsToOrder, CREATE_ORDERING));
-        // Update mode:
-        opsToOrder = [];
-        for (const op of unit.update) {
-            if (handledOpKinds.has(op.kind)) {
-                opsToOrder.push(op);
-                OpList.remove(op);
-            }
-            else {
-                OpList.insertBefore(reorder(opsToOrder, UPDATE_ORDERING), op);
-                opsToOrder = [];
+    }
+    // Propagate i18n params from sub-templates up to the root i18n op.
+    for (const op of i18nOps.values()) {
+        if (op.xref !== op.root) {
+            const rootOp = i18nOps.get(op.root);
+            for (const [placeholder, value] of op.params) {
+                rootOp.params.set(placeholder, value);
             }
         }
-        unit.update.push(reorder(opsToOrder, UPDATE_ORDERING));
     }
-}
-/**
- * Reorders the given list of ops according to the ordering defined by `ORDERING`.
- */
-function reorder(ops, ordering) {
-    // Break the ops list into groups based on OpKind.
-    const groups = Array.from(ordering, () => new Array());
-    for (const op of ops) {
-        const groupIndex = ordering.findIndex(o => o.test(op));
-        groups[groupIndex].push(op);
+    // Validate the root i18n ops have all placeholders filled in.
+    for (const op of i18nOps.values()) {
+        if (op.xref === op.root) {
+            for (const placeholder in op.message.placeholders) {
+                if (!op.params.has(placeholder)) {
+                    throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
+                }
+            }
+        }
     }
-    // Reassemble the groups into a single list, in the correct order.
-    return groups.flatMap((group, i) => {
-        const transform = ordering[i].transform;
-        return transform ? transform(group) : group;
-    });
-}
-/**
- * Keeps only the last op in a list of ops.
- */
-function keepLast(ops) {
-    return ops.slice(ops.length - 1);
 }
 
 function phasePureFunctionExtraction(job) {
@@ -19402,7 +19908,7 @@ class PureFunctionConstant extends GenericKeyFn {
     toSharedConstantDeclaration(declName, keyExpr) {
         const fnParams = [];
         for (let idx = 0; idx < this.numArgs; idx++) {
-            fnParams.push(new FnParam('_p' + idx));
+            fnParams.push(new FnParam('a' + idx));
         }
         // We will never visit `ir.PureFunctionParameterExpr`s that don't belong to us, because this
         // transform runs inside another visitor which will visit nested pure functions before this one.
@@ -19410,9 +19916,9 @@ class PureFunctionConstant extends GenericKeyFn {
             if (!(expr instanceof PureFunctionParameterExpr)) {
                 return expr;
             }
-            return variable('_p' + expr.index);
+            return variable('a' + expr.index);
         }, VisitorContextFlag.None);
-        return new DeclareFunctionStmt(declName, fnParams, [new ReturnStatement(returnExpr)]);
+        return new DeclareVarStmt(declName, new ArrowFunctionExpr(fnParams, returnExpr), undefined, StmtModifier.Final);
     }
 }
 
@@ -19576,6 +20082,25 @@ function text(slot, initialValue, sourceSpan) {
     }
     return call(Identifiers.text, args, sourceSpan);
 }
+function defer(selfSlot, primarySlot, dependencyResolverFn, loadingSlot, placeholderSlot, errorSlot, loadingConfigIndex, placeholderConfigIndex, sourceSpan) {
+    const args = [
+        literal(selfSlot),
+        literal(primarySlot),
+        literal(dependencyResolverFn),
+        literal(loadingSlot),
+        literal(placeholderSlot),
+        literal(errorSlot),
+        literal(loadingConfigIndex),
+        literal(placeholderConfigIndex),
+    ];
+    while (args[args.length - 1].value === null) {
+        args.pop();
+    }
+    return call(Identifiers.defer, args, sourceSpan);
+}
+function deferOn(sourceSpan) {
+    return call(Identifiers.deferOnIdle, [], sourceSpan);
+}
 function projectionDef(def) {
     return call(Identifiers.projectionDef, def ? [def] : [], null);
 }
@@ -19589,11 +20114,19 @@ function projection(slot, projectionSlotIndex, attributes) {
     }
     return call(Identifiers.projection, args, null);
 }
-function i18nStart(slot, constIndex) {
-    return call(Identifiers.i18nStart, [literal(slot), literal(constIndex)], null);
+function i18nStart(slot, constIndex, subTemplateIndex) {
+    const args = [literal(slot), literal(constIndex)];
+    if (subTemplateIndex !== null) {
+        args.push(literal(subTemplateIndex));
+    }
+    return call(Identifiers.i18nStart, args, null);
 }
-function i18n(slot) {
-    return call(Identifiers.i18n, [literal(slot)], null);
+function i18n(slot, constIndex, subTemplateIndex) {
+    const args = [literal(slot), literal(constIndex)];
+    if (subTemplateIndex) {
+        args.push(literal(subTemplateIndex));
+    }
+    return call(Identifiers.i18n, args, null);
 }
 function i18nEnd() {
     return call(Identifiers.i18nEnd, [], null);
@@ -19670,6 +20203,12 @@ function textInterpolate(strings, expressions, sourceSpan) {
     }
     return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs, [], sourceSpan);
 }
+function i18nExp(expr, sourceSpan) {
+    return call(Identifiers.i18nExp, [expr], sourceSpan);
+}
+function i18nApply(slot, sourceSpan) {
+    return call(Identifiers.i18nApply, [literal(slot)], sourceSpan);
+}
 function propertyInterpolate(name, strings, expressions, sanitizer, sourceSpan) {
     const interpolationArgs = collateInterpolationArgs(strings, expressions);
     const extraArgs = [];
@@ -19739,8 +20278,12 @@ function call(instruction, args, sourceSpan) {
     const expr = importExpr(instruction).callFn(args, sourceSpan);
     return createStatementOp(new ExpressionStatement(expr, sourceSpan));
 }
-function conditional(slot, condition) {
-    return call(Identifiers.conditional, [literal(slot), condition], null);
+function conditional(slot, condition, contextValue, sourceSpan) {
+    const args = [literal(slot), condition];
+    if (contextValue !== null) {
+        args.push(contextValue);
+    }
+    return call(Identifiers.conditional, args, sourceSpan);
 }
 /**
  * `InterpolationConfig` for the `textInterpolate` instruction.
@@ -19966,20 +20509,20 @@ function reifyCreateOperations(unit, ops) {
                 OpList.replace(op, elementContainerEnd());
                 break;
             case OpKind.I18nStart:
-                OpList.replace(op, i18nStart(op.slot, op.messageIndex));
+                OpList.replace(op, i18nStart(op.slot, op.messageIndex, op.subTemplateIndex));
                 break;
             case OpKind.I18nEnd:
                 OpList.replace(op, i18nEnd());
                 break;
             case OpKind.I18n:
-                OpList.replace(op, i18n(op.slot));
+                OpList.replace(op, i18n(op.slot, op.messageIndex, op.subTemplateIndex));
                 break;
             case OpKind.Template:
                 if (!(unit instanceof ViewCompilationUnit)) {
                     throw new Error(`AssertionError: must be compiling a component`);
                 }
                 const childView = unit.job.views.get(op.xref);
-                OpList.replace(op, template(op.slot, variable(childView.fnName), childView.decls, childView.vars, op.controlFlow ? null : op.tag, op.attributes, op.sourceSpan));
+                OpList.replace(op, template(op.slot, variable(childView.fnName), childView.decls, childView.vars, op.block ? null : op.tag, op.attributes, op.sourceSpan));
                 break;
             case OpKind.DisableBindings:
                 OpList.replace(op, disableBindings());
@@ -20016,6 +20559,15 @@ function reifyCreateOperations(unit, ops) {
                         break;
                 }
                 break;
+            case OpKind.Defer:
+                OpList.replace(op, defer(op.slot, op.targetSlot, null, op.loading && op.loading.targetSlot, op.placeholder && op.placeholder.targetSlot, op.error && op.error.targetSlot, op.loading?.constIndex ?? null, op.placeholder?.constIndex ?? null, op.sourceSpan));
+                break;
+            case OpKind.DeferSecondaryBlock:
+                OpList.remove(op);
+                break;
+            case OpKind.DeferOn:
+                OpList.replace(op, deferOn(op.sourceSpan));
+                break;
             case OpKind.ProjectionDef:
                 OpList.replace(op, projectionDef(op.def));
                 break;
@@ -20075,6 +20627,12 @@ function reifyUpdateOperations(_unit, ops) {
                     OpList.replace(op, classMap(op.expression, op.sourceSpan));
                 }
                 break;
+            case OpKind.I18nExpression:
+                OpList.replace(op, i18nExp(op.expression, op.sourceSpan));
+                break;
+            case OpKind.I18nApply:
+                OpList.replace(op, i18nApply(op.targetSlot, op.sourceSpan));
+                break;
             case OpKind.InterpolateText:
                 OpList.replace(op, textInterpolate(op.interpolation.strings, op.interpolation.expressions, op.sourceSpan));
                 break;
@@ -20109,10 +20667,10 @@ function reifyUpdateOperations(_unit, ops) {
                 if (op.processed === null) {
                     throw new Error(`Conditional test was not set.`);
                 }
-                if (op.slot === null) {
+                if (op.targetSlot === null) {
                     throw new Error(`Conditional slot was not set.`);
                 }
-                OpList.replace(op, conditional(op.slot, op.processed));
+                OpList.replace(op, conditional(op.targetSlot, op.processed, op.contextValue, op.sourceSpan));
                 break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
@@ -20130,7 +20688,7 @@ function reifyIrExpression(expr) {
         case ExpressionKind.NextContext:
             return nextContext(expr.steps);
         case ExpressionKind.Reference:
-            return reference(expr.slot + 1 + expr.offset);
+            return reference(expr.targetSlot + 1 + expr.offset);
         case ExpressionKind.LexicalRead:
             throw new Error(`AssertionError: unresolved LexicalRead of ${expr.name}`);
         case ExpressionKind.RestoreView:
@@ -20165,13 +20723,13 @@ function reifyIrExpression(expr) {
         case ExpressionKind.PureFunctionParameterExpr:
             throw new Error(`AssertionError: expected PureFunctionParameterExpr to have been extracted`);
         case ExpressionKind.PipeBinding:
-            return pipeBind(expr.slot, expr.varOffset, expr.args);
+            return pipeBind(expr.targetSlot, expr.varOffset, expr.args);
         case ExpressionKind.PipeBindingVariadic:
-            return pipeBindV(expr.slot, expr.varOffset, expr.args);
+            return pipeBindV(expr.targetSlot, expr.varOffset, expr.args);
         case ExpressionKind.SanitizerExpr:
             return importExpr(sanitizerIdentifierMap.get(expr.fn));
         case ExpressionKind.SlotLiteralExpr:
-            return literal(expr.slot);
+            return literal(expr.targetSlot);
         default:
             throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${ExpressionKind[expr.kind]}`);
     }
@@ -20290,58 +20848,186 @@ function resolveDollarEvent(unit, ops) {
         }
     }
 }
-
-/**
- * The escape sequence used indicate message param values.
- */
-const ESCAPE = '\uFFFD';
+
+/**
+ * The escape sequence used indicate message param values.
+ */
+const ESCAPE = '\uFFFD';
+/**
+ * Marker used to indicate an element tag.
+ */
+const ELEMENT_MARKER = '#';
+/**
+ * Marker used to indicate a template tag.
+ */
+const TEMPLATE_MARKER = '*';
+/**
+ * Marker used to indicate closing of an element or template tag.
+ */
+const TAG_CLOSE_MARKER = '/';
+/**
+ * Marker used to indicate the sub-template context.
+ */
+const CONTEXT_MARKER = ':';
+/**
+ * Marker used to indicate the start of a list of values.
+ */
+const LIST_START_MARKER = '[';
+/**
+ * Marker used to indicate the end of a list of values.
+ */
+const LIST_END_MARKER = ']';
+/**
+ * Delimiter used to separate multiple values in a list.
+ */
+const LIST_DELIMITER = '|';
+var I18nParamValueFlags;
+(function (I18nParamValueFlags) {
+    I18nParamValueFlags[I18nParamValueFlags["None"] = 0] = "None";
+    /**
+     *  This value represtents an element tag.
+     */
+    I18nParamValueFlags[I18nParamValueFlags["ElementTag"] = 1] = "ElementTag";
+    /**
+     * This value represents a template tag.
+     */
+    I18nParamValueFlags[I18nParamValueFlags["TemplateTag"] = 2] = "TemplateTag";
+    /**
+     * This value represents the closing of a tag. (Can only be used together with ElementTag or
+     * TemplateTag)
+     */
+    I18nParamValueFlags[I18nParamValueFlags["CloseTag"] = 4] = "CloseTag";
+})(I18nParamValueFlags || (I18nParamValueFlags = {}));
+/**
+ * Represents the complete i18n params map for an i18n op.
+ */
+class I18nPlaceholderParams {
+    constructor() {
+        this.values = new Map();
+    }
+    /**
+     * Adds a new value to the params map.
+     */
+    addValue(placeholder, value, subTemplateIndex, flags) {
+        const placeholderValues = this.values.get(placeholder) ?? [];
+        placeholderValues.push({ value, subTemplateIndex, flags });
+        this.values.set(placeholder, placeholderValues);
+    }
+    /**
+     * Saves the params map, in serialized form, into the given i18n op.
+     */
+    saveToOp(op) {
+        for (const [placeholder, placeholderValues] of this.values) {
+            op.params.set(placeholder, literal(this.serializeValues(placeholderValues)));
+        }
+    }
+    /**
+     * Serializes a list of i18n placeholder values.
+     */
+    serializeValues(values) {
+        const serializedValues = values.map(value => this.serializeValue(value));
+        return serializedValues.length === 1 ?
+            serializedValues[0] :
+            `${LIST_START_MARKER}${serializedValues.join(LIST_DELIMITER)}${LIST_END_MARKER}`;
+    }
+    /**
+     * Serializes a single i18n placeholder value.
+     */
+    serializeValue(value) {
+        let tagMarker = '';
+        let closeMarker = '';
+        if (value.flags & I18nParamValueFlags.ElementTag) {
+            tagMarker = ELEMENT_MARKER;
+        }
+        else if (value.flags & I18nParamValueFlags.TemplateTag) {
+            tagMarker = TEMPLATE_MARKER;
+        }
+        if (tagMarker !== '') {
+            closeMarker = value.flags & I18nParamValueFlags.CloseTag ? TAG_CLOSE_MARKER : '';
+        }
+        const context = value.subTemplateIndex === null ? '' : `${CONTEXT_MARKER}${value.subTemplateIndex}`;
+        return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+    }
+}
 /**
  * Resolve the placeholders in i18n messages.
  */
 function phaseResolveI18nPlaceholders(job) {
     for (const unit of job.units) {
-        let i18nOp = null;
-        let startTags = [];
-        let closeTags = [];
+        const i18nOps = new Map();
+        const params = new Map();
+        let currentI18nOp = null;
+        // Record slots for tag name placeholders.
         for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart && op.i18n instanceof Message) {
-                i18nOp = op;
-            }
-            else if (op.kind === OpKind.I18nEnd) {
-                i18nOp = null;
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                case OpKind.I18n:
+                    i18nOps.set(op.xref, op);
+                    currentI18nOp = op.kind === OpKind.I18nStart ? op : null;
+                    break;
+                case OpKind.I18nEnd:
+                    currentI18nOp = null;
+                    break;
+                case OpKind.Element:
+                case OpKind.ElementStart:
+                case OpKind.Template:
+                    // For elements with i18n placeholders, record its slot value in the params map under both
+                    // the start and close placeholders.
+                    if (op.i18nPlaceholder !== undefined) {
+                        if (currentI18nOp === null) {
+                            throw Error('i18n tag placeholder should only occur inside an i18n block');
+                        }
+                        const { startName, closeName } = op.i18nPlaceholder;
+                        const subTemplateIndex = getSubTemplateIndexForTag(job, currentI18nOp, op);
+                        const flags = op.kind === OpKind.Template ? I18nParamValueFlags.TemplateTag :
+                            I18nParamValueFlags.ElementTag;
+                        addParam(params, currentI18nOp, startName, op.slot, subTemplateIndex, flags);
+                        addParam(params, currentI18nOp, closeName, op.slot, subTemplateIndex, flags | I18nParamValueFlags.CloseTag);
+                    }
+                    break;
             }
-            else if ((op.kind === OpKind.Element || op.kind === OpKind.ElementStart) &&
-                op.i18n instanceof TagPlaceholder) {
-                if (i18nOp === null) {
-                    throw Error('i18n tag placeholder should only occur inside an i18n block');
+        }
+        // Fill in values for each of the i18n expression placeholders.
+        const i18nBlockPlaceholderIndices = new Map();
+        for (const op of unit.update) {
+            if (op.kind === OpKind.I18nExpression) {
+                const i18nOp = i18nOps.get(op.owner);
+                let index = i18nBlockPlaceholderIndices.get(op.owner) || 0;
+                if (!i18nOp) {
+                    throw Error('Cannot find corresponding i18nStart for i18nExpr');
                 }
-                // In order to add the keys in the same order as TemplateDefinitionBuilder, we separately
-                // track the start and close tag placeholders.
-                // TODO: when TemplateDefinitionBuilder compatibility is not required, we can just add both
-                //  keys directly to the map here.
-                startTags.push({
-                    i18nOp,
-                    placeholder: op.i18n.startName,
-                    value: literal(`${ESCAPE}#${op.slot}${ESCAPE}`)
-                });
-                closeTags.push({
-                    i18nOp,
-                    placeholder: op.i18n.closeName,
-                    value: literal(`${ESCAPE}/#${op.slot}${ESCAPE}`)
-                });
+                addParam(params, i18nOp, op.i18nPlaceholder.name, index++, i18nOp.subTemplateIndex);
+                i18nBlockPlaceholderIndices.set(op.owner, index);
             }
         }
-        // Add the start tags in the order we encountered them, to match TemplateDefinitionBuilder.
-        for (const { i18nOp, placeholder, value } of startTags) {
-            i18nOp.tagNameParams[placeholder] = value;
+        // After colleccting all params, save them to the i18n ops.
+        for (const [xref, i18nOpParams] of params) {
+            i18nOpParams.saveToOp(i18nOps.get(xref));
         }
-        // Add the close tags in reverse order that we encountered the start tags, to match
-        // TemplateDefinitionBuilder.
-        for (let i = closeTags.length - 1; i >= 0; i--) {
-            const { i18nOp, placeholder, value } = closeTags[i];
-            i18nOp.tagNameParams[placeholder] = value;
+    }
+}
+/**
+ * Add a param to the params map for the given i18n op.
+ */
+function addParam(params, i18nOp, placeholder, value, subTemplateIndex, flags = I18nParamValueFlags.None) {
+    const i18nOpParams = params.get(i18nOp.xref) ?? new I18nPlaceholderParams();
+    i18nOpParams.addValue(placeholder, value, subTemplateIndex, flags);
+    params.set(i18nOp.xref, i18nOpParams);
+}
+/**
+ * Get the subTemplateIndex for the given op. For template ops, use the subTemplateIndex of the
+ * child i18n block inside the template. For all other ops, use the subTemplateIndex of the i18n
+ * block the op belongs to.
+ */
+function getSubTemplateIndexForTag(job, i18nOp, op) {
+    if (op.kind === OpKind.Template) {
+        for (const childOp of job.views.get(op.xref).create) {
+            if (childOp.kind === OpKind.I18nStart) {
+                return childOp.subTemplateIndex;
+            }
         }
     }
+    return i18nOp.subTemplateIndex;
 }
 
 /**
@@ -20586,19 +21272,19 @@ function phaseSlotAllocation(job) {
                 const childView = job.views.get(op.xref);
                 op.decls = childView.decls;
             }
-            if (hasUsesSlotIndexTrait(op) && op.slot === null) {
+            if (hasUsesSlotIndexTrait(op) && op.targetSlot === null) {
                 if (!slotMap.has(op.target)) {
                     // We do expect to find a slot allocated for everything which might be referenced.
                     throw new Error(`AssertionError: no slot allocated for ${OpKind[op.kind]} target ${op.target}`);
                 }
-                op.slot = slotMap.get(op.target);
+                op.targetSlot = slotMap.get(op.target);
             }
             // Process all `ir.Expression`s within this view, and look for `usesSlotIndexExprTrait`.
             visitExpressionsInOp(op, expr => {
                 if (!isIrExpression(expr)) {
                     return;
                 }
-                if (!hasUsesSlotIndexTrait(expr) || expr.slot !== null) {
+                if (!hasUsesSlotIndexTrait(expr) || expr.targetSlot !== null) {
                     return;
                 }
                 // The `UsesSlotIndexExprTrait` indicates that this expression references something declared
@@ -20609,7 +21295,7 @@ function phaseSlotAllocation(job) {
                     throw new Error(`AssertionError: no slot allocated for ${expr.constructor.name} target ${expr.target}`);
                 }
                 // Record the allocated slot on the expression.
-                expr.slot = slotMap.get(expr.target);
+                expr.targetSlot = slotMap.get(expr.target);
             });
         }
     }
@@ -20660,47 +21346,62 @@ function phaseStyleBindingSpecialization(cpl) {
  */
 function phaseTemporaryVariables(cpl) {
     for (const unit of cpl.units) {
-        let opCount = 0;
-        let generatedStatements = [];
-        for (const op of unit.ops()) {
-            // Identify the final time each temp var is read.
-            const finalReads = new Map();
-            visitExpressionsInOp(op, expr => {
-                if (expr instanceof ReadTemporaryExpr) {
-                    finalReads.set(expr.xref, expr);
-                }
-            });
-            // Name the temp vars, accounting for the fact that a name can be reused after it has been
-            // read for the final time.
-            let count = 0;
-            const assigned = new Set();
-            const released = new Set();
-            const defs = new Map();
-            visitExpressionsInOp(op, expr => {
-                if (expr instanceof AssignTemporaryExpr) {
-                    if (!assigned.has(expr.xref)) {
-                        assigned.add(expr.xref);
-                        // TODO: Exactly replicate the naming scheme used by `TemplateDefinitionBuilder`.
-                        // It seems to rely on an expression index instead of an op index.
-                        defs.set(expr.xref, `tmp_${opCount}_${count++}`);
-                    }
-                    assignName(defs, expr);
+        unit.create.prepend(generateTemporaries(unit.create));
+        unit.update.prepend(generateTemporaries(unit.update));
+    }
+}
+function generateTemporaries(ops) {
+    let opCount = 0;
+    let generatedStatements = [];
+    // For each op, search for any variables that are assigned or read. For each variable, generate a
+    // name and produce a `DeclareVarStmt` to the beginning of the block.
+    for (const op of ops) {
+        // Identify the final time each temp var is read.
+        const finalReads = new Map();
+        visitExpressionsInOp(op, (expr, flag) => {
+            if (flag & VisitorContextFlag.InChildOperation) {
+                return;
+            }
+            if (expr instanceof ReadTemporaryExpr) {
+                finalReads.set(expr.xref, expr);
+            }
+        });
+        // Name the temp vars, accounting for the fact that a name can be reused after it has been
+        // read for the final time.
+        let count = 0;
+        const assigned = new Set();
+        const released = new Set();
+        const defs = new Map();
+        visitExpressionsInOp(op, (expr, flag) => {
+            if (flag & VisitorContextFlag.InChildOperation) {
+                return;
+            }
+            if (expr instanceof AssignTemporaryExpr) {
+                if (!assigned.has(expr.xref)) {
+                    assigned.add(expr.xref);
+                    // TODO: Exactly replicate the naming scheme used by `TemplateDefinitionBuilder`.
+                    // It seems to rely on an expression index instead of an op index.
+                    defs.set(expr.xref, `tmp_${opCount}_${count++}`);
                 }
-                else if (expr instanceof ReadTemporaryExpr) {
-                    if (finalReads.get(expr.xref) === expr) {
-                        released.add(expr.xref);
-                        count--;
-                    }
-                    assignName(defs, expr);
+                assignName(defs, expr);
+            }
+            else if (expr instanceof ReadTemporaryExpr) {
+                if (finalReads.get(expr.xref) === expr) {
+                    released.add(expr.xref);
+                    count--;
                 }
-            });
-            // Add declarations for the temp vars.
-            generatedStatements.push(...Array.from(new Set(defs.values()))
-                .map(name => createStatementOp(new DeclareVarStmt(name))));
-            opCount++;
+                assignName(defs, expr);
+            }
+        });
+        // Add declarations for the temp vars.
+        generatedStatements.push(...Array.from(new Set(defs.values()))
+            .map(name => createStatementOp(new DeclareVarStmt(name))));
+        opCount++;
+        if (op.kind === OpKind.Listener) {
+            op.handlerOps.prepend(generateTemporaries(op.handlerOps));
         }
-        unit.update.prepend(generatedStatements);
     }
+    return generatedStatements;
 }
 /**
  * Assigns a name to the temporary variable in the given temporary variable expression.
@@ -21068,6 +21769,13 @@ function allowConservativeInlining(decl, target) {
     // that behavior here.
     switch (decl.variable.kind) {
         case SemanticVariableKind.Identifier:
+            if (decl.initializer instanceof ReadVarExpr && decl.initializer.name === 'ctx') {
+                // Although TemplateDefinitionBuilder is cautious about inlining, we still want to do so
+                // when the variable is the context, to imitate its behavior with aliases in control flow
+                // blocks. This quirky behavior will become dead code once compatibility mode is no longer
+                // supported.
+                return true;
+            }
             return false;
         case SemanticVariableKind.Context:
             // Context can only be inlined into other variables.
@@ -21077,111 +21785,20 @@ function allowConservativeInlining(decl, target) {
     }
 }
 
-/**
- * Locate projection slots, populate the each component's `ngContentSelectors` literal field,
- * populate `project` arguments, and generate the required `projectionDef` instruction for the job's
- * root view.
- */
-function phaseGenerateProjectionDef(job) {
-    // TODO: Why does TemplateDefinitionBuilder force a shared constant?
-    const share = job.compatibility === CompatibilityMode.TemplateDefinitionBuilder;
-    // Collect all selectors from this component, and its nested views. Also, assign each projection a
-    // unique ascending projection slot index.
-    const selectors = [];
-    let projectionSlotIndex = 0;
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.Projection) {
-                selectors.push(op.selector);
-                op.projectionSlotIndex = projectionSlotIndex++;
-            }
-        }
-    }
-    if (selectors.length > 0) {
-        // Create the projectionDef array. If we only found a single wildcard selector, then we use the
-        // default behavior with no arguments instead.
-        let defExpr = null;
-        if (selectors.length > 1 || selectors[0] !== '*') {
-            const def = selectors.map(s => s === '*' ? s : parseSelectorToR3Selector(s));
-            defExpr = job.pool.getConstLiteral(literalOrArrayLiteral(def), share);
-        }
-        // Create the ngContentSelectors constant.
-        job.contentSelectors = job.pool.getConstLiteral(literalOrArrayLiteral(selectors), share);
-        // The projection def instruction goes at the beginning of the root view, before any
-        // `projection` instructions.
-        job.root.create.prepend([createProjectionDefOp(defExpr)]);
-    }
-}
-
-/**
- * Lifts i18n properties into the consts array.
- */
-function phaseI18nConstCollection(job) {
-    // Serialize the extracted messages into the const array.
-    // TODO: Use `Map` instead of object.
-    const messageConstIndices = {};
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.ExtractedMessage) {
-                messageConstIndices[op.owner] = job.addConst(op.expression, op.statements);
-                OpList.remove(op);
-            }
-        }
-    }
-    // Assign const index to i18n ops that messages were extracted from.
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart && messageConstIndices[op.xref] !== undefined) {
-                op.messageIndex = messageConstIndices[op.xref];
-            }
-        }
-    }
-}
-
-/**
- * Attributes of `ng-content` named 'select' are specifically removed, because they control which
- * content matches as a property of the `projection`, and are not a plain attribute.
- */
-function phaseRemoveContentSelectors(job) {
-    for (const unit of job.units) {
-        const elements = getElementsByXrefId(unit);
-        for (const op of unit.update) {
-            switch (op.kind) {
-                case OpKind.Binding:
-                    const target = lookupElement(elements, op.target);
-                    if (op.name.toLowerCase() === 'select' && target.kind === OpKind.Projection) {
-                        OpList.remove(op);
-                    }
-                    continue;
-            }
-        }
-    }
-}
-/**
- * Looks up an element in the given map by xref ID.
- */
-function lookupElement(elements, xref) {
-    const el = elements.get(xref);
-    if (el === undefined) {
-        throw new Error('All attributes should have an element-like target.');
-    }
-    return el;
-}
-
 const phases = [
     { kind: CompilationJobKind.Tmpl, fn: phaseRemoveContentSelectors },
-    { kind: CompilationJobKind.Tmpl, fn: phaseGenerateI18nBlocks },
-    { kind: CompilationJobKind.Tmpl, fn: phaseI18nTextExtraction },
     { kind: CompilationJobKind.Host, fn: phaseHostStylePropertyParsing },
     { kind: CompilationJobKind.Tmpl, fn: phaseNamespace },
     { kind: CompilationJobKind.Both, fn: phaseStyleBindingSpecialization },
     { kind: CompilationJobKind.Both, fn: phaseBindingSpecialization },
+    { kind: CompilationJobKind.Tmpl, fn: phasePropagateI18nBlocks },
     { kind: CompilationJobKind.Both, fn: phaseAttributeExtraction },
     { kind: CompilationJobKind.Both, fn: phaseParseExtractedStyles },
     { kind: CompilationJobKind.Tmpl, fn: phaseRemoveEmptyBindings },
     { kind: CompilationJobKind.Tmpl, fn: phaseConditionals },
-    { kind: CompilationJobKind.Tmpl, fn: phaseNoListenersOnTemplates },
     { kind: CompilationJobKind.Tmpl, fn: phasePipeCreation },
+    { kind: CompilationJobKind.Tmpl, fn: phaseI18nTextExtraction },
+    { kind: CompilationJobKind.Tmpl, fn: phaseApplyI18nExpressions },
     { kind: CompilationJobKind.Tmpl, fn: phasePipeVariadic },
     { kind: CompilationJobKind.Both, fn: phasePureLiteralStructures },
     { kind: CompilationJobKind.Tmpl, fn: phaseGenerateProjectionDef },
@@ -21198,9 +21815,12 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: phaseTemporaryVariables },
     { kind: CompilationJobKind.Tmpl, fn: phaseSlotAllocation },
     { kind: CompilationJobKind.Tmpl, fn: phaseResolveI18nPlaceholders },
+    { kind: CompilationJobKind.Tmpl, fn: phasePropagateI18nPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nMessageExtraction },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nConstCollection },
+    { kind: CompilationJobKind.Tmpl, fn: phaseConstTraitCollection },
     { kind: CompilationJobKind.Both, fn: phaseConstCollection },
+    { kind: CompilationJobKind.Tmpl, fn: phaseAssignI18nSlotDependencies },
     { kind: CompilationJobKind.Both, fn: phaseVarCounting },
     { kind: CompilationJobKind.Tmpl, fn: phaseGenerateAdvance },
     { kind: CompilationJobKind.Both, fn: phaseVariableOptimization },
@@ -21404,9 +22024,15 @@ function ingestNodes(unit, template) {
         else if (node instanceof BoundText) {
             ingestBoundText(unit, node);
         }
+        else if (node instanceof IfBlock) {
+            ingestIfBlock(unit, node);
+        }
         else if (node instanceof SwitchBlock) {
             ingestSwitchBlock(unit, node);
         }
+        else if (node instanceof DeferredBlock) {
+            ingestDeferBlock(unit, node);
+        }
         else {
             throw new Error(`Unsupported template node: ${node.constructor.name}`);
         }
@@ -21416,31 +22042,47 @@ function ingestNodes(unit, template) {
  * Ingest an element AST from the template into the given `ViewCompilation`.
  */
 function ingestElement(unit, element) {
+    if (element.i18n !== undefined &&
+        !(element.i18n instanceof Message || element.i18n instanceof TagPlaceholder)) {
+        throw Error(`Unhandled i18n metadata type for element: ${element.i18n.constructor.name}`);
+    }
     const staticAttributes = {};
     for (const attr of element.attributes) {
         staticAttributes[attr.name] = attr.value;
     }
     const id = unit.job.allocateXrefId();
     const [namespaceKey, elementName] = splitNsName(element.name);
-    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n, element.startSourceSpan);
+    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n instanceof TagPlaceholder ? element.i18n : undefined, element.startSourceSpan);
     unit.create.push(startOp);
     ingestBindings(unit, startOp, element);
     ingestReferences(startOp, element);
     ingestNodes(unit, element.children);
-    unit.create.push(createElementEndOp(id, element.endSourceSpan));
+    const endOp = createElementEndOp(id, element.endSourceSpan);
+    unit.create.push(endOp);
+    // If there is an i18n message associated with this element, insert i18n start and end ops.
+    if (element.i18n instanceof Message) {
+        const i18nBlockId = unit.job.allocateXrefId();
+        OpList.insertAfter(createI18nStartOp(i18nBlockId, element.i18n), startOp);
+        OpList.insertBefore(createI18nEndOp(i18nBlockId), endOp);
+    }
 }
 /**
  * Ingest an `ng-template` node from the AST into the given `ViewCompilation`.
  */
 function ingestTemplate(unit, tmpl) {
+    if (tmpl.i18n !== undefined &&
+        !(tmpl.i18n instanceof Message || tmpl.i18n instanceof TagPlaceholder)) {
+        throw Error(`Unhandled i18n metadata type for template: ${tmpl.i18n.constructor.name}`);
+    }
     const childView = unit.job.allocateView(unit.xref);
     let tagNameWithoutNamespace = tmpl.tagName;
     let namespacePrefix = '';
     if (tmpl.tagName) {
         [namespacePrefix, tagNameWithoutNamespace] = splitNsName(tmpl.tagName);
     }
+    const i18nPlaceholder = tmpl.i18n instanceof TagPlaceholder ? tmpl.i18n : undefined;
     // TODO: validate the fallback tag name here.
-    const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace ?? 'ng-template', namespaceForKey(namespacePrefix), false, tmpl.i18n, tmpl.startSourceSpan);
+    const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace ?? 'ng-template', namespaceForKey(namespacePrefix), false, i18nPlaceholder, tmpl.startSourceSpan);
     unit.create.push(tplOp);
     ingestBindings(unit, tplOp, tmpl);
     ingestReferences(tplOp, tmpl);
@@ -21448,6 +22090,12 @@ function ingestTemplate(unit, tmpl) {
     for (const { name, value } of tmpl.variables) {
         childView.contextVariables.set(name, value);
     }
+    // If there is an i18n message associated with this template, insert i18n start and end ops.
+    if (tmpl.i18n instanceof Message) {
+        const id = unit.job.allocateXrefId();
+        OpList.insertAfter(createI18nStartOp(id, tmpl.i18n), childView.create.head);
+        OpList.insertBefore(createI18nEndOp(id), childView.create.tail);
+    }
 }
 /**
  * Ingest a literal text node from the AST into the given `ViewCompilation`.
@@ -21455,7 +22103,7 @@ function ingestTemplate(unit, tmpl) {
 function ingestContent(unit, content) {
     const op = createProjectionOp(unit.job.allocateXrefId(), content.selector);
     for (const attr of content.attributes) {
-        ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, true, false);
+        ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, BindingFlags.TextValue);
     }
     unit.create.push(op);
 }
@@ -21476,35 +22124,109 @@ function ingestBoundText(unit, text) {
     if (!(value instanceof Interpolation$1)) {
         throw new Error(`AssertionError: expected Interpolation for BoundText node, got ${value.constructor.name}`);
     }
+    if (text.i18n !== undefined && !(text.i18n instanceof Container)) {
+        throw Error(`Unhandled i18n metadata type for text interpolation: ${text.i18n?.constructor.name}`);
+    }
+    const i18nPlaceholders = text.i18n instanceof Container ?
+        text.i18n.children.filter((node) => node instanceof Placeholder) :
+        [];
     const textXref = unit.job.allocateXrefId();
     unit.create.push(createTextOp(textXref, '', text.sourceSpan));
     // TemplateDefinitionBuilder does not generate source maps for sub-expressions inside an
     // interpolation. We copy that behavior in compatibility mode.
     // TODO: is it actually correct to generate these extra maps in modern mode?
     const baseSourceSpan = unit.job.compatibility ? null : text.sourceSpan;
-    unit.update.push(createInterpolateTextOp(textXref, new Interpolation(value.strings, value.expressions.map(expr => convertAst(expr, unit.job, baseSourceSpan))), text.sourceSpan));
+    unit.update.push(createInterpolateTextOp(textXref, new Interpolation(value.strings, value.expressions.map(expr => convertAst(expr, unit.job, baseSourceSpan))), i18nPlaceholders, text.sourceSpan));
+}
+/**
+ * Ingest an `@if` block into the given `ViewCompilation`.
+ */
+function ingestIfBlock(unit, ifBlock) {
+    let firstXref = null;
+    let conditions = [];
+    for (const ifCase of ifBlock.branches) {
+        const cView = unit.job.allocateView(unit.xref);
+        if (ifCase.expressionAlias !== null) {
+            cView.contextVariables.set(ifCase.expressionAlias.name, CTX_REF);
+        }
+        if (firstXref === null) {
+            firstXref = cView.xref;
+        }
+        unit.create.push(createTemplateOp(cView.xref, 'Conditional', Namespace.HTML, true, undefined /* TODO: figure out how i18n works with new control flow */, ifCase.sourceSpan));
+        const caseExpr = ifCase.expression ? convertAst(ifCase.expression, unit.job, null) : null;
+        const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, cView.xref, ifCase.expressionAlias);
+        conditions.push(conditionalCaseExpr);
+        ingestNodes(cView, ifCase.children);
+    }
+    const conditional = createConditionalOp(firstXref, null, conditions, ifBlock.sourceSpan);
+    unit.update.push(conditional);
 }
 /**
- * Ingest a `@switch` block into the given `ViewCompilation`.
+ * Ingest an `@switch` block into the given `ViewCompilation`.
  */
 function ingestSwitchBlock(unit, switchBlock) {
     let firstXref = null;
     let conditions = [];
     for (const switchCase of switchBlock.cases) {
         const cView = unit.job.allocateView(unit.xref);
-        if (!firstXref)
+        if (firstXref === null) {
             firstXref = cView.xref;
-        unit.create.push(createTemplateOp(cView.xref, 'Case', Namespace.HTML, true, undefined, null));
+        }
+        unit.create.push(createTemplateOp(cView.xref, 'Case', Namespace.HTML, true, undefined /* TODO: figure out how i18n works with new control flow */, switchCase.sourceSpan));
         const caseExpr = switchCase.expression ?
             convertAst(switchCase.expression, unit.job, switchBlock.startSourceSpan) :
             null;
-        conditions.push([cView.xref, caseExpr]);
+        const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, cView.xref);
+        conditions.push(conditionalCaseExpr);
         ingestNodes(cView, switchCase.children);
     }
-    const conditional = createConditionalOp(firstXref, convertAst(switchBlock.expression, unit.job, switchBlock.startSourceSpan), null);
-    conditional.conditions = conditions;
+    const conditional = createConditionalOp(firstXref, convertAst(switchBlock.expression, unit.job, null), conditions, switchBlock.sourceSpan);
     unit.update.push(conditional);
 }
+function ingestDeferView(unit, suffix, children, sourceSpan) {
+    if (children === undefined) {
+        return null;
+    }
+    const secondaryView = unit.job.allocateView(unit.xref);
+    ingestNodes(secondaryView, children);
+    const templateOp = createTemplateOp(secondaryView.xref, `Defer${suffix}`, Namespace.HTML, true, undefined, sourceSpan);
+    unit.create.push(templateOp);
+    return templateOp;
+}
+function ingestDeferBlock(unit, deferBlock) {
+    // Generate the defer main view and all secondary views.
+    const main = ingestDeferView(unit, '', deferBlock.children, deferBlock.sourceSpan);
+    const loading = ingestDeferView(unit, 'Loading', deferBlock.loading?.children, deferBlock.loading?.sourceSpan);
+    const placeholder = ingestDeferView(unit, 'Placeholder', deferBlock.placeholder?.children, deferBlock.placeholder?.sourceSpan);
+    const error = ingestDeferView(unit, 'Error', deferBlock.error?.children, deferBlock.error?.sourceSpan);
+    // Create the main defer op, and ops for all secondary views.
+    const deferOp = createDeferOp(unit.job.allocateXrefId(), main.xref, deferBlock.sourceSpan);
+    unit.create.push(deferOp);
+    if (loading && deferBlock.loading) {
+        deferOp.loading =
+            createDeferSecondaryOp(deferOp.xref, loading.xref, DeferSecondaryKind.Loading);
+        if (deferBlock.loading.afterTime !== null || deferBlock.loading.minimumTime !== null) {
+            deferOp.loading.constValue = [deferBlock.loading.minimumTime, deferBlock.loading.afterTime];
+        }
+        unit.create.push(deferOp.loading);
+    }
+    if (placeholder && deferBlock.placeholder) {
+        deferOp.placeholder = createDeferSecondaryOp(deferOp.xref, placeholder.xref, DeferSecondaryKind.Placeholder);
+        if (deferBlock.placeholder.minimumTime !== null) {
+            deferOp.placeholder.constValue = [deferBlock.placeholder.minimumTime];
+        }
+        unit.create.push(deferOp.placeholder);
+    }
+    if (error && deferBlock.error) {
+        deferOp.error =
+            createDeferSecondaryOp(deferOp.xref, error.xref, DeferSecondaryKind.Error);
+        unit.create.push(deferOp.error);
+    }
+    // Configure all defer conditions.
+    const deferOnOp = createDeferOnOp(unit.job.allocateXrefId(), null);
+    // Add all ops to the view.
+    unit.create.push(deferOnOp);
+}
 /**
  * Convert a template AST expression into an output AST expression.
  */
@@ -21603,13 +22325,20 @@ function convertAst(ast, job, baseSourceSpan) {
  * to their IR representation.
  */
 function ingestBindings(unit, op, element) {
+    let flags = BindingFlags.None;
+    const isPlainTemplate = element instanceof Template && splitNsName(element.tagName ?? '')[1] === 'ng-template';
     if (element instanceof Template) {
+        flags |= BindingFlags.OnNgTemplateElement;
+        if (isPlainTemplate) {
+            flags |= BindingFlags.BindingTargetsTemplate;
+        }
+        const templateAttrFlags = flags | BindingFlags.BindingTargetsTemplate | BindingFlags.IsStructuralTemplateAttribute;
         for (const attr of element.templateAttrs) {
             if (attr instanceof TextAttribute) {
-                ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, true, true);
+                ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, templateAttrFlags | BindingFlags.TextValue);
             }
             else {
-                ingestBinding(unit, op.xref, attr.name, attr.value, attr.type, attr.unit, attr.securityContext, attr.sourceSpan, false, true);
+                ingestBinding(unit, op.xref, attr.name, attr.value, attr.type, attr.unit, attr.securityContext, attr.sourceSpan, templateAttrFlags);
             }
         }
     }
@@ -21617,10 +22346,10 @@ function ingestBindings(unit, op, element) {
         // This is only attribute TextLiteral bindings, such as `attr.foo="bar"`. This can never be
         // `[attr.foo]="bar"` or `attr.foo="{{bar}}"`, both of which will be handled as inputs with
         // `BindingType.Attribute`.
-        ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, true, false);
+        ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, flags | BindingFlags.TextValue);
     }
     for (const input of element.inputs) {
-        ingestBinding(unit, op.xref, input.name, input.value, input.type, input.unit, input.securityContext, input.sourceSpan, false, false);
+        ingestBinding(unit, op.xref, input.name, input.value, input.type, input.unit, input.securityContext, input.sourceSpan, flags);
     }
     for (const output of element.outputs) {
         let listenerOp;
@@ -21629,6 +22358,10 @@ function ingestBindings(unit, op, element) {
                 throw Error('Animation listener should have a phase');
             }
         }
+        if (element instanceof Template && !isPlainTemplate) {
+            unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, output.name, null));
+            continue;
+        }
         listenerOp =
             createListenerOp(op.xref, output.name, op.tag, output.phase, false, output.sourceSpan);
         // if output.handler is a chain, then push each statement from the chain separately, and
@@ -21664,10 +22397,37 @@ const BINDING_KINDS = new Map([
     [3 /* e.BindingType.Style */, BindingKind.StyleProperty],
     [4 /* e.BindingType.Animation */, BindingKind.Animation],
 ]);
-function ingestBinding(view, xref, name, value, type, unit, securityContext, sourceSpan, isTextAttribute, isTemplateBinding) {
+var BindingFlags;
+(function (BindingFlags) {
+    BindingFlags[BindingFlags["None"] = 0] = "None";
+    /**
+     * The binding is to a static text literal and not to an expression.
+     */
+    BindingFlags[BindingFlags["TextValue"] = 1] = "TextValue";
+    /**
+     * The binding belongs to the `<ng-template>` side of a `t.Template`.
+     */
+    BindingFlags[BindingFlags["BindingTargetsTemplate"] = 2] = "BindingTargetsTemplate";
+    /**
+     * The binding is on a structural directive.
+     */
+    BindingFlags[BindingFlags["IsStructuralTemplateAttribute"] = 4] = "IsStructuralTemplateAttribute";
+    /**
+     * The binding is on a `t.Template`.
+     */
+    BindingFlags[BindingFlags["OnNgTemplateElement"] = 8] = "OnNgTemplateElement";
+})(BindingFlags || (BindingFlags = {}));
+function ingestBinding(view, xref, name, value, type, unit, securityContext, sourceSpan, flags) {
     if (value instanceof ASTWithSource) {
         value = value.ast;
     }
+    if (flags & BindingFlags.OnNgTemplateElement && !(flags & BindingFlags.BindingTargetsTemplate) &&
+        type === 0 /* e.BindingType.Property */) {
+        // This binding only exists for later const extraction, and is not an actual binding to be
+        // created.
+        view.create.push(createExtractedAttributeOp(xref, BindingKind.Property, name, null));
+        return;
+    }
     let expression;
     // TODO: We could easily generate source maps for subexpressions in these cases, but
     // TemplateDefinitionBuilder does not. Should we do so?
@@ -21681,7 +22441,7 @@ function ingestBinding(view, xref, name, value, type, unit, securityContext, sou
         expression = value;
     }
     const kind = BINDING_KINDS.get(type);
-    view.update.push(createBindingOp(xref, kind, name, expression, unit, securityContext, isTextAttribute, isTemplateBinding, sourceSpan));
+    view.update.push(createBindingOp(xref, kind, name, expression, unit, securityContext, !!(flags & BindingFlags.TextValue), !!(flags & BindingFlags.IsStructuralTemplateAttribute), sourceSpan));
 }
 /**
  * Process all of the local references on an element-like structure in the template AST and
@@ -22862,13 +23622,13 @@ function normalizeNgContentSelect(selectAttr) {
 /** Pattern for the expression in a for loop block. */
 const FOR_LOOP_EXPRESSION_PATTERN = /^\s*([0-9A-Za-z_$]*)\s+of\s+(.*)/;
 /** Pattern for the tracking expression in a for loop block. */
-const FOR_LOOP_TRACK_PATTERN = /^track\s+(.*)/;
+const FOR_LOOP_TRACK_PATTERN = /^track\s+([\S\s]*)/;
 /** Pattern for the `as` expression in a conditional block. */
 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+(.*)/;
+const FOR_LOOP_LET_PATTERN = /^let\s+([\S\s]*)/;
 /** Names of variables that are allowed to be used in the `let` expression of a `for` loop. */
 const ALLOWED_FOR_LOOP_LET_VARIABLES = new Set(['$index', '$first', '$last', '$even', '$odd', '$count']);
 /**
@@ -22889,28 +23649,33 @@ function isConnectedIfLoopBlock(name) {
 function createIfBlock(ast, connectedBlocks, visitor, bindingParser) {
     const errors = validateIfConnectedBlocks(connectedBlocks);
     const branches = [];
-    if (errors.length > 0) {
-        return { node: null, errors };
-    }
     const mainBlockParams = parseConditionalBlockParameters(ast, errors, bindingParser);
     if (mainBlockParams !== null) {
-        branches.push(new IfBlockBranch(mainBlockParams.expression, visitAll(visitor, ast.children, ast.children), mainBlockParams.expressionAlias, ast.sourceSpan, ast.startSourceSpan));
+        branches.push(new IfBlockBranch(mainBlockParams.expression, visitAll(visitor, ast.children, ast.children), mainBlockParams.expressionAlias, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan));
     }
-    // Assumes that the structure is valid since we validated it above.
     for (const block of connectedBlocks) {
-        const children = visitAll(visitor, block.children, block.children);
         if (ELSE_IF_PATTERN.test(block.name)) {
             const params = parseConditionalBlockParameters(block, errors, bindingParser);
             if (params !== null) {
-                branches.push(new IfBlockBranch(params.expression, children, params.expressionAlias, block.sourceSpan, block.startSourceSpan));
+                const children = visitAll(visitor, block.children, block.children);
+                branches.push(new IfBlockBranch(params.expression, children, params.expressionAlias, block.sourceSpan, block.startSourceSpan, block.endSourceSpan));
             }
         }
         else if (block.name === 'else') {
-            branches.push(new IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan));
+            const children = visitAll(visitor, block.children, block.children);
+            branches.push(new IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan, block.endSourceSpan));
         }
     }
+    // The outer IfBlock should have a span that encapsulates all branches.
+    const ifBlockStartSourceSpan = branches.length > 0 ? branches[0].startSourceSpan : ast.startSourceSpan;
+    const ifBlockEndSourceSpan = branches.length > 0 ? branches[branches.length - 1].endSourceSpan : ast.endSourceSpan;
+    let wholeSourceSpan = ast.sourceSpan;
+    const lastBranch = branches[branches.length - 1];
+    if (lastBranch !== undefined) {
+        wholeSourceSpan = new ParseSourceSpan(ifBlockStartSourceSpan.start, lastBranch.sourceSpan.end);
+    }
     return {
-        node: new IfBlock(branches, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+        node: new IfBlock(branches, wholeSourceSpan, ast.startSourceSpan, ifBlockEndSourceSpan),
         errors,
     };
 }
@@ -22929,7 +23694,7 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
                 errors.push(new ParseError(block.sourceSpan, '@empty block cannot have parameters'));
             }
             else {
-                empty = new ForLoopBlockEmpty(visitAll(visitor, block.children, block.children), block.sourceSpan, block.startSourceSpan);
+                empty = new ForLoopBlockEmpty(visitAll(visitor, block.children, block.children), block.sourceSpan, block.startSourceSpan, block.endSourceSpan);
             }
         }
         else {
@@ -22938,10 +23703,16 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
     }
     if (params !== null) {
         if (params.trackBy === null) {
+            // TODO: We should not fail here, and instead try to produce some AST for the language
+            // service.
             errors.push(new ParseError(ast.sourceSpan, '@for loop must have a "track" expression'));
         }
         else {
-            node = new ForLoopBlock(params.itemName, params.expression, params.trackBy, params.context, visitAll(visitor, ast.children, ast.children), empty, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+            // The `for` block has a main span that includes the `empty` branch. For only the span of the
+            // main `for` body, use `mainSourceSpan`.
+            const endSpan = empty?.endSourceSpan ?? ast.endSourceSpan;
+            const sourceSpan = new ParseSourceSpan(ast.sourceSpan.start, endSpan?.end ?? ast.sourceSpan.end);
+            node = new ForLoopBlock(params.itemName, params.expression, params.trackBy, params.context, visitAll(visitor, ast.children, ast.children), empty, sourceSpan, ast.sourceSpan, ast.startSourceSpan, endSpan);
         }
     }
     return { node, errors };
@@ -22949,21 +23720,25 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
 /** Creates a switch block from an HTML AST node. */
 function createSwitchBlock(ast, visitor, bindingParser) {
     const errors = validateSwitchBlock(ast);
-    if (errors.length > 0) {
-        return { node: null, errors };
-    }
-    const primaryExpression = parseBlockParameterToBinding(ast.parameters[0], bindingParser);
+    const primaryExpression = ast.parameters.length > 0 ?
+        parseBlockParameterToBinding(ast.parameters[0], bindingParser) :
+        bindingParser.parseBinding('', false, ast.sourceSpan, 0);
     const cases = [];
+    const unknownBlocks = [];
     let defaultCase = null;
     // Here we assume that all the blocks are valid given that we validated them above.
     for (const node of ast.children) {
         if (!(node instanceof Block)) {
             continue;
         }
+        if ((node.name !== 'case' || node.parameters.length === 0) && node.name !== 'default') {
+            unknownBlocks.push(new UnknownBlock(node.name, node.sourceSpan));
+            continue;
+        }
         const expression = node.name === 'case' ?
             parseBlockParameterToBinding(node.parameters[0], bindingParser) :
             null;
-        const ast = new SwitchBlockCase(expression, visitAll(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan);
+        const ast = new SwitchBlockCase(expression, visitAll(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan, node.endSourceSpan);
         if (expression === null) {
             defaultCase = ast;
         }
@@ -22976,7 +23751,7 @@ function createSwitchBlock(ast, visitor, bindingParser) {
         cases.push(defaultCase);
     }
     return {
-        node: new SwitchBlock(primaryExpression, cases, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+        node: new SwitchBlock(primaryExpression, cases, unknownBlocks, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
         errors
     };
 }
@@ -23020,8 +23795,10 @@ function parseForLoopParameters(block, errors, bindingParser) {
     // Fill out any variables that haven't been defined explicitly.
     for (const variableName of ALLOWED_FOR_LOOP_LET_VARIABLES) {
         if (!result.context.hasOwnProperty(variableName)) {
-            result.context[variableName] =
-                new Variable(variableName, variableName, block.startSourceSpan, block.startSourceSpan);
+            // Give ambiently-available context variables empty spans at the end of the start of the `for`
+            // block, since they are not explicitly defined.
+            const emptySpanAfterForBlockStart = new ParseSourceSpan(block.startSourceSpan.end, block.startSourceSpan.end);
+            result.context[variableName] = new Variable(variableName, variableName, emptySpanAfterForBlockStart, emptySpanAfterForBlockStart);
         }
     }
     return result;
@@ -23516,7 +24293,17 @@ function createDeferredBlock(ast, connectedBlocks, visitor, bindingParser) {
     const errors = [];
     const { placeholder, loading, error } = parseConnectedBlocks(connectedBlocks, errors, visitor);
     const { triggers, prefetchTriggers } = parsePrimaryTriggers(ast.parameters, bindingParser, errors, placeholder);
-    const node = new DeferredBlock(visitAll(visitor, ast.children, ast.children), triggers, prefetchTriggers, placeholder, loading, error, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+    // The `defer` block has a main span encompassing all of the connected branches as well. For the
+    // span of only the first "main" branch, use `mainSourceSpan`.
+    let lastEndSourceSpan = ast.endSourceSpan;
+    let endOfLastSourceSpan = ast.sourceSpan.end;
+    if (connectedBlocks.length > 0) {
+        const lastConnectedBlock = connectedBlocks[connectedBlocks.length - 1];
+        lastEndSourceSpan = lastConnectedBlock.endSourceSpan;
+        endOfLastSourceSpan = lastConnectedBlock.sourceSpan.end;
+    }
+    const mainDeferredSourceSpan = new ParseSourceSpan(ast.sourceSpan.start, endOfLastSourceSpan);
+    const node = new DeferredBlock(visitAll(visitor, ast.children, ast.children), triggers, prefetchTriggers, placeholder, loading, error, mainDeferredSourceSpan, ast.sourceSpan, ast.startSourceSpan, lastEndSourceSpan);
     return { node, errors };
 }
 function parseConnectedBlocks(connectedBlocks, errors, visitor) {
@@ -23891,26 +24678,6 @@ class HtmlAstToIvyAst {
         if (this.processedNodes.has(block)) {
             return null;
         }
-        if (!this.options.enabledBlockTypes.has(block.name)) {
-            let errorMessage;
-            if (isConnectedDeferLoopBlock(block.name)) {
-                errorMessage = `@${block.name} block can only be used after an @defer block.`;
-                this.processedNodes.add(block);
-            }
-            else if (isConnectedForLoopBlock(block.name)) {
-                errorMessage = `@${block.name} block can only be used after an @for block.`;
-                this.processedNodes.add(block);
-            }
-            else if (isConnectedIfLoopBlock(block.name)) {
-                errorMessage = `@${block.name} block can only be used after an @if or @else if block.`;
-                this.processedNodes.add(block);
-            }
-            else {
-                errorMessage = `Unrecognized block @${block.name}.`;
-            }
-            this.reportError(errorMessage, block.sourceSpan);
-            return null;
-        }
         let result = null;
         switch (block.name) {
             case 'defer':
@@ -23926,9 +24693,25 @@ class HtmlAstToIvyAst {
                 result = createIfBlock(block, this.findConnectedBlocks(index, context, isConnectedIfLoopBlock), this, this.bindingParser);
                 break;
             default:
+                let errorMessage;
+                if (isConnectedDeferLoopBlock(block.name)) {
+                    errorMessage = `@${block.name} block can only be used after an @defer block.`;
+                    this.processedNodes.add(block);
+                }
+                else if (isConnectedForLoopBlock(block.name)) {
+                    errorMessage = `@${block.name} block can only be used after an @for block.`;
+                    this.processedNodes.add(block);
+                }
+                else if (isConnectedIfLoopBlock(block.name)) {
+                    errorMessage = `@${block.name} block can only be used after an @if or @else if block.`;
+                    this.processedNodes.add(block);
+                }
+                else {
+                    errorMessage = `Unrecognized block @${block.name}.`;
+                }
                 result = {
-                    node: null,
-                    errors: [new ParseError(block.sourceSpan, `Unrecognized block @${block.name}.`)]
+                    node: new UnknownBlock(block.name, block.sourceSpan),
+                    errors: [new ParseError(block.sourceSpan, errorMessage)],
                 };
                 break;
         }
@@ -24517,6 +25300,7 @@ class TemplateDefinitionBuilder {
         this.visitIfBlockBranch = invalid;
         this.visitSwitchBlockCase = invalid;
         this.visitForLoopBlockEmpty = invalid;
+        this.visitUnknownBlock = invalid;
         this._bindingScope = parentBindingScope.nestedScope(level);
         // Turn the relative context file path into an identifier by replacing non-alphanumeric
         // characters with underscores.
@@ -25242,18 +26026,17 @@ class TemplateDefinitionBuilder {
         // callback in order to generate the correct expressions when pipes or pure functions are
         // used inside the branch expressions.
         const branchData = block.branches.map(({ expression, expressionAlias, children, sourceSpan }) => {
-            const processedExpression = expression === null ? null : expression.visit(this._valueConverter);
             // If the branch has an alias, it'll be assigned directly to the container's context.
             // We define a variable referring directly to the context so that any nested usages can be
             // rewritten to refer to it.
             const variables = expressionAlias !== null ?
                 [new Variable(expressionAlias.name, DIRECT_CONTEXT_REFERENCE, expressionAlias.sourceSpan, expressionAlias.keySpan)] :
                 undefined;
-            return {
-                index: this.createEmbeddedTemplateFn(null, children, '_Conditional', sourceSpan, variables),
-                expression: processedExpression,
-                alias: expressionAlias
-            };
+            // Note: the template needs to be created *before* we process the expression,
+            // otherwise pipes injecting some symbols won't work (see #52102).
+            const index = this.createEmbeddedTemplateFn(null, children, '_Conditional', sourceSpan, variables);
+            const processedExpression = expression === null ? null : expression.visit(this._valueConverter);
+            return { index, expression: processedExpression, alias: expressionAlias };
         });
         // Use the index of the first block as the index for the entire container.
         const containerIndex = branchData[0].index;
@@ -25299,20 +26082,21 @@ class TemplateDefinitionBuilder {
         this.updateInstructionWithAdvance(containerIndex, block.branches[0].sourceSpan, Identifiers.conditional, paramsCallback);
     }
     visitSwitchBlock(block) {
-        const blockExpression = block.expression.visit(this._valueConverter);
-        this.allocateBindingSlots(null); // Allocate a slot for the primary block expression.
         // We have to process the block in two steps: once here and again in the update instruction
         // callback in order to generate the correct expressions when pipes or pure functions are used.
         const caseData = block.cases.map(currentCase => {
-            return {
-                index: this.createEmbeddedTemplateFn(null, currentCase.children, '_Case', currentCase.sourceSpan),
-                expression: currentCase.expression === null ?
-                    null :
-                    currentCase.expression.visit(this._valueConverter)
-            };
+            const index = this.createEmbeddedTemplateFn(null, currentCase.children, '_Case', currentCase.sourceSpan);
+            const expression = currentCase.expression === null ?
+                null :
+                currentCase.expression.visit(this._valueConverter);
+            return { index, expression };
         });
         // Use the index of the first block as the index for the entire container.
         const containerIndex = caseData[0].index;
+        // Note: the expression needs to be processed *after* the template,
+        // otherwise pipes injecting some symbols won't work (see #52102).
+        const blockExpression = block.expression.visit(this._valueConverter);
+        this.allocateBindingSlots(null); // Allocate a slot for the primary block expression.
         this.updateInstructionWithAdvance(containerIndex, block.sourceSpan, Identifiers.conditional, () => {
             const generateCases = (caseIndex) => {
                 // If we've gone beyond the last branch, return the special -1
@@ -25380,12 +26164,17 @@ class TemplateDefinitionBuilder {
             literal(errorIndex),
             loadingConsts?.length ? this.addToConsts(literalArr(loadingConsts)) : TYPED_NULL_EXPR,
             placeholderConsts ? this.addToConsts(placeholderConsts) : TYPED_NULL_EXPR,
+            (loadingConsts?.length || placeholderConsts) ?
+                importExpr(Identifiers.deferEnableTimerScheduling) :
+                TYPED_NULL_EXPR,
         ]));
-        this.createDeferTriggerInstructions(deferredIndex, triggers, metadata, false);
-        this.createDeferTriggerInstructions(deferredIndex, prefetchTriggers, metadata, true);
         // Allocate an extra data slot right after a defer block slot to store
         // instance-specific state of that defer block at runtime.
         this.allocateDataSlot();
+        // Note: the triggers need to be processed *after* the various templates,
+        // otherwise pipes injecting some symbols won't work (see #52102).
+        this.createDeferTriggerInstructions(deferredIndex, triggers, metadata, false);
+        this.createDeferTriggerInstructions(deferredIndex, prefetchTriggers, metadata, true);
     }
     createDeferredDepsFunction(name, metadata) {
         if (metadata.deps.length === 0) {
@@ -25477,12 +26266,13 @@ class TemplateDefinitionBuilder {
         // are implicitly inferred by the runtime to index + 1 and index + 2.
         const blockIndex = this.allocateDataSlot();
         const primaryData = this.prepareEmbeddedTemplateFn(block.children, '_For', [block.item, block.contextVariables.$index, block.contextVariables.$count]);
-        const emptyData = block.empty === null ?
-            null :
-            this.prepareEmbeddedTemplateFn(block.empty.children, '_ForEmpty');
         const { expression: trackByExpression, usesComponentInstance: trackByUsesComponentInstance } = this.createTrackByFunction(block);
-        const value = block.expression.visit(this._valueConverter);
-        this.allocateBindingSlots(value);
+        let emptyData = null;
+        if (block.empty !== null) {
+            emptyData = this.prepareEmbeddedTemplateFn(block.empty.children, '_ForEmpty');
+            // Allocate an extra slot for the empty block tracking.
+            this.allocateBindingSlots(null);
+        }
         this.registerComputedLoopVariables(block, primaryData.scope);
         // `repeaterCreate(0, ...)`
         this.creationInstruction(block.sourceSpan, Identifiers.repeaterCreate, () => {
@@ -25502,6 +26292,11 @@ class TemplateDefinitionBuilder {
             }
             return params;
         });
+        // Note: the expression needs to be processed *after* the template,
+        // otherwise pipes injecting some symbols won't work (see #52102).
+        // Note: we don't allocate binding slots for this expression,
+        // because its value isn't stored in the LView.
+        const value = block.expression.visit(this._valueConverter);
         // `repeater(0, iterable)`
         this.updateInstruction(block.sourceSpan, Identifiers.repeater, () => [literal(blockIndex), this.convertPropertyBinding(value)]);
     }
@@ -26377,7 +27172,7 @@ function parseTemplate(template, templateUrl, options = {}) {
         leadingTriviaChars: LEADING_TRIVIA_CHARS,
         ...options,
         tokenizeExpansionForms: true,
-        tokenizeBlocks: options.enabledBlockTypes != null && options.enabledBlockTypes.size > 0,
+        tokenizeBlocks: options.enableBlockSyntax ?? true,
     });
     if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors &&
         parseResult.errors.length > 0) {
@@ -26429,10 +27224,7 @@ function parseTemplate(template, templateUrl, options = {}) {
             rootNodes = visitAll(new I18nMetaVisitor(interpolationConfig, /* keepI18nAttrs */ false), rootNodes);
         }
     }
-    const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, {
-        collectCommentNodes: !!options.collectCommentNodes,
-        enabledBlockTypes: options.enabledBlockTypes || new Set(),
-    });
+    const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, { collectCommentNodes: !!options.collectCommentNodes });
     errors.push(...parseResult.errors, ...i18nMetaResult.errors);
     const parsedTemplate = {
         interpolationConfig,
@@ -26707,14 +27499,14 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         // - 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];
+        //   `consts: () => { 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)]);
+                constsExpr = arrowFn([], [...prepareStatements, new ReturnStatement(constsExpr)]);
             }
             definitionMap.set('consts', constsExpr);
         }
@@ -26735,7 +27527,9 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         definitionMap.set('vars', literal(tpl.root.vars));
         if (tpl.consts.length > 0) {
             if (tpl.constsInitializers.length > 0) {
-                definitionMap.set('consts', fn([], [...tpl.constsInitializers, new ReturnStatement(literalArr(tpl.consts))]));
+                definitionMap.set('consts', arrowFn([], [
+                    ...tpl.constsInitializers, new ReturnStatement(literalArr(tpl.consts))
+                ]));
             }
             else {
                 definitionMap.set('consts', literalArr(tpl.consts));
@@ -26829,11 +27623,11 @@ function compileDeclarationList(list, mode) {
             return list;
         case 1 /* DeclarationListEmitMode.Closure */:
             // directives: function () { return [MyDir]; }
-            return fn([], [new ReturnStatement(list)]);
+            return arrowFn([], list);
         case 2 /* DeclarationListEmitMode.ClosureResolved */:
             // directives: function () { return [MyDir].map(ng.resolveForwardRef); }
             const resolvedList = list.prop('map').callFn([importExpr(Identifiers.resolveForwardRef)]);
-            return fn([], [new ReturnStatement(resolvedList)]);
+            return arrowFn([], resolvedList);
         case 3 /* DeclarationListEmitMode.RuntimeResolved */:
             throw new Error(`Unsupported with an array of pre-resolved dependencies`);
     }
@@ -27523,6 +28317,7 @@ class Scope {
     visitTextAttribute(attr) { }
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
+    visitUnknownBlock(block) { }
     maybeDeclare(thing) {
         // Declare something with a name, as long as that name isn't taken.
         if (!this.namedEntities.has(thing.name)) {
@@ -27724,6 +28519,7 @@ class DirectiveBinder {
     visitBoundText(text) { }
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
+    visitUnknownBlock(block) { }
 }
 /**
  * Processes a template and extract metadata about expressions and symbols within.
@@ -27852,6 +28648,8 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitText(text) { }
     visitContent(content) { }
     visitTextAttribute(attribute) { }
+    visitUnknownBlock(block) { }
+    visitDeferredTrigger() { }
     visitIcu(icu) {
         Object.keys(icu.vars).forEach(key => icu.vars[key].visit(this));
         Object.keys(icu.placeholders).forEach(key => icu.placeholders[key].visit(this));
@@ -27866,15 +28664,12 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitDeferredBlock(deferred) {
         this.deferBlocks.add(deferred);
         this.ingestScopedNode(deferred);
+        deferred.triggers.when?.value.visit(this);
+        deferred.prefetchTriggers.when?.value.visit(this);
         deferred.placeholder && this.visitNode(deferred.placeholder);
         deferred.loading && this.visitNode(deferred.loading);
         deferred.error && this.visitNode(deferred.error);
     }
-    visitDeferredTrigger(trigger) {
-        if (trigger instanceof BoundDeferredTrigger) {
-            trigger.value.visit(this);
-        }
-    }
     visitDeferredBlockPlaceholder(block) {
         this.ingestScopedNode(block);
     }
@@ -28113,11 +28908,6 @@ function extractScopedNodeEntities(rootScope) {
 class ResourceLoader {
 }
 
-let enabledBlockTypes;
-/** Temporary utility that enables specific block types in JIT compilations. */
-function ɵsetEnabledBlockTypes(types) {
-    enabledBlockTypes = types.length > 0 ? new Set(types) : undefined;
-}
 class CompilerFacadeImpl {
     constructor(jitEvaluator = new JitEvaluator()) {
         this.jitEvaluator = jitEvaluator;
@@ -28523,7 +29313,7 @@ function convertPipeDeclarationToMetadata(pipe) {
 function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces, interpolation) {
     const interpolationConfig = interpolation ? InterpolationConfig.fromArray(interpolation) : DEFAULT_INTERPOLATION_CONFIG;
     // Parse the template and check for errors.
-    const parsed = parseTemplate(template, sourceMapUrl, { preserveWhitespaces, interpolationConfig, enabledBlockTypes });
+    const parsed = parseTemplate(template, sourceMapUrl, { preserveWhitespaces, interpolationConfig });
     if (parsed.errors !== null) {
         const errors = parsed.errors.map(err => err.toString()).join(', ');
         throw new Error(`Errors during JIT compilation of template for ${typeName}: ${errors}`);
@@ -28736,13 +29526,11 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.0.0-next.6');
+const VERSION = new Version('17.0.0-next.8');
 
 class CompilerConfig {
-    constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, useJit = true, missingTranslation = null, preserveWhitespaces, strictInjectionParameters } = {}) {
+    constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
         this.defaultEncapsulation = defaultEncapsulation;
-        this.useJit = !!useJit;
-        this.missingTranslation = missingTranslation;
         this.preserveWhitespaces = preserveWhitespacesDefault(noUndefined(preserveWhitespaces));
         this.strictInjectionParameters = strictInjectionParameters === true;
     }
@@ -30232,6 +31020,31 @@ function compileComponentClassMetadata(metadata, deferrableTypes) {
     return iife.callFn([]);
 }
 
+/**
+ * Generate an ngDevMode guarded call to setClassDebugInfo with the debug info about the class
+ * (e.g., the file name in which the class is defined)
+ */
+function compileClassDebugInfo(debugInfo) {
+    const debugInfoObject = {
+        className: debugInfo.className,
+    };
+    // Include file path and line number only if the file relative path is calculated successfully.
+    if (debugInfo.filePath) {
+        debugInfoObject.filePath = debugInfo.filePath;
+        debugInfoObject.lineNumber = debugInfo.lineNumber;
+    }
+    // Include forbidOrphanRendering only if it's set to true (to reduce generated code)
+    if (debugInfo.forbidOrphanRendering) {
+        debugInfoObject.forbidOrphanRendering = literal(true);
+    }
+    const fnCall = importExpr(Identifiers.setClassDebugInfo).callFn([
+        debugInfo.type,
+        mapLiteral(debugInfoObject),
+    ]);
+    const iife = arrowFn([], [devOnlyGuardedExpression(fnCall).toStmt()]);
+    return iife.callFn([]);
+}
+
 /**
  * Every time we make a breaking change to the declaration interface or partial-linker behavior, we
  * must update this constant to prevent old partial-linkers from incorrectly processing the
@@ -30243,7 +31056,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('17.0.0-next.6'));
+    definitionMap.set('version', literal('17.0.0-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -30351,7 +31164,7 @@ function createDirectiveDefinitionMap(meta) {
     // in 16.1 is actually used.
     const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION$5 : '14.0.0';
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('17.0.0-next.6'));
+    definitionMap.set('version', literal('17.0.0-next.8'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -30477,10 +31290,17 @@ function compileDeclareComponentFromMetadata(meta, template, additionalTemplateI
  */
 function createComponentDefinitionMap(meta, template, templateInfo) {
     const definitionMap = createDirectiveDefinitionMap(meta);
+    const blockVisitor = new BlockPresenceVisitor();
+    visitAll$1(blockVisitor, template.nodes);
     definitionMap.set('template', getTemplateExpression(template, templateInfo));
     if (templateInfo.isInline) {
         definitionMap.set('isInline', literal(true));
     }
+    // Set the minVersion to 17.0.0 if the component is using at least one block in its template.
+    // We don't do this for templates without blocks, in order to preserve backwards compatibility.
+    if (blockVisitor.hasBlocks) {
+        definitionMap.set('minVersion', literal('17.0.0'));
+    }
     definitionMap.set('styles', toOptionalLiteralArray(meta.styles, literal));
     definitionMap.set('dependencies', compileUsedDependenciesMetadata(meta));
     definitionMap.set('viewProviders', meta.viewProviders);
@@ -30573,6 +31393,42 @@ function compileUsedDependenciesMetadata(meta) {
         }
     });
 }
+class BlockPresenceVisitor extends RecursiveVisitor$1 {
+    constructor() {
+        super(...arguments);
+        this.hasBlocks = false;
+    }
+    visitDeferredBlock() {
+        this.hasBlocks = true;
+    }
+    visitDeferredBlockPlaceholder() {
+        this.hasBlocks = true;
+    }
+    visitDeferredBlockLoading() {
+        this.hasBlocks = true;
+    }
+    visitDeferredBlockError() {
+        this.hasBlocks = true;
+    }
+    visitIfBlock() {
+        this.hasBlocks = true;
+    }
+    visitIfBlockBranch() {
+        this.hasBlocks = true;
+    }
+    visitForLoopBlock() {
+        this.hasBlocks = true;
+    }
+    visitForLoopBlockEmpty() {
+        this.hasBlocks = true;
+    }
+    visitSwitchBlock() {
+        this.hasBlocks = true;
+    }
+    visitSwitchBlockCase() {
+        this.hasBlocks = true;
+    }
+}
 
 /**
  * Every time we make a breaking change to the declaration interface or partial-linker behavior, we
@@ -30585,7 +31441,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('17.0.0-next.6'));
+    definitionMap.set('version', literal('17.0.0-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -30620,7 +31476,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('17.0.0-next.6'));
+    definitionMap.set('version', literal('17.0.0-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -30671,7 +31527,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('17.0.0-next.6'));
+    definitionMap.set('version', literal('17.0.0-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -30704,7 +31560,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('17.0.0-next.6'));
+    definitionMap.set('version', literal('17.0.0-next.8'));
     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.
@@ -30755,7 +31611,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('17.0.0-next.6'));
+    definitionMap.set('version', literal('17.0.0-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -30788,5 +31644,5 @@ publishFacade(_global);
 
 // This file is not used to build this module. It is only used during editing
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, UnknownBlock as TmplAstUnknownBlock, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map