@angular/compiler 17.0.0-rc.0 → 17.0.0-rc.1

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-rc.0
+ * @license Angular v17.0.0-rc.1
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -3983,9 +3983,10 @@ class IfBlockBranch {
     }
 }
 class UnknownBlock {
-    constructor(name, sourceSpan) {
+    constructor(name, sourceSpan, nameSpan) {
         this.name = name;
         this.sourceSpan = sourceSpan;
+        this.nameSpan = nameSpan;
     }
     visit(visitor) {
         return visitor.visitUnknownBlock(this);
@@ -8826,34 +8827,42 @@ var OpKind;
      * Create a content projection slot.
      */
     OpKind[OpKind["Projection"] = 33] = "Projection";
+    /**
+     * Create a repeater creation instruction op.
+     */
+    OpKind[OpKind["RepeaterCreate"] = 34] = "RepeaterCreate";
+    /**
+     * An update up for a repeater.
+     */
+    OpKind[OpKind["Repeater"] = 35] = "Repeater";
     /**
      * The start of an i18n block.
      */
-    OpKind[OpKind["I18nStart"] = 34] = "I18nStart";
+    OpKind[OpKind["I18nStart"] = 36] = "I18nStart";
     /**
      * A self-closing i18n on a single element.
      */
-    OpKind[OpKind["I18n"] = 35] = "I18n";
+    OpKind[OpKind["I18n"] = 37] = "I18n";
     /**
      * The end of an i18n block.
      */
-    OpKind[OpKind["I18nEnd"] = 36] = "I18nEnd";
+    OpKind[OpKind["I18nEnd"] = 38] = "I18nEnd";
     /**
      * An expression in an i18n message.
      */
-    OpKind[OpKind["I18nExpression"] = 37] = "I18nExpression";
+    OpKind[OpKind["I18nExpression"] = 39] = "I18nExpression";
     /**
      * An instruction that applies a set of i18n expressions.
      */
-    OpKind[OpKind["I18nApply"] = 38] = "I18nApply";
+    OpKind[OpKind["I18nApply"] = 40] = "I18nApply";
     /**
      * An instruction to create an ICU expression.
      */
-    OpKind[OpKind["Icu"] = 39] = "Icu";
+    OpKind[OpKind["Icu"] = 41] = "Icu";
     /**
      * An instruction to update an ICU expression.
      */
-    OpKind[OpKind["IcuUpdate"] = 40] = "IcuUpdate";
+    OpKind[OpKind["IcuUpdate"] = 42] = "IcuUpdate";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -8868,87 +8877,106 @@ var ExpressionKind;
      * A reference to the current view context.
      */
     ExpressionKind[ExpressionKind["Context"] = 1] = "Context";
+    /**
+     * A reference to the view context, for use inside a track function.
+     */
+    ExpressionKind[ExpressionKind["TrackContext"] = 2] = "TrackContext";
     /**
      * Read of a variable declared in a `VariableOp`.
      */
-    ExpressionKind[ExpressionKind["ReadVariable"] = 2] = "ReadVariable";
+    ExpressionKind[ExpressionKind["ReadVariable"] = 3] = "ReadVariable";
     /**
      * Runtime operation to navigate to the next view context in the view hierarchy.
      */
-    ExpressionKind[ExpressionKind["NextContext"] = 3] = "NextContext";
+    ExpressionKind[ExpressionKind["NextContext"] = 4] = "NextContext";
     /**
      * Runtime operation to retrieve the value of a local reference.
      */
-    ExpressionKind[ExpressionKind["Reference"] = 4] = "Reference";
+    ExpressionKind[ExpressionKind["Reference"] = 5] = "Reference";
     /**
      * Runtime operation to snapshot the current view context.
      */
-    ExpressionKind[ExpressionKind["GetCurrentView"] = 5] = "GetCurrentView";
+    ExpressionKind[ExpressionKind["GetCurrentView"] = 6] = "GetCurrentView";
     /**
      * Runtime operation to restore a snapshotted view.
      */
-    ExpressionKind[ExpressionKind["RestoreView"] = 6] = "RestoreView";
+    ExpressionKind[ExpressionKind["RestoreView"] = 7] = "RestoreView";
     /**
      * Runtime operation to reset the current view context after `RestoreView`.
      */
-    ExpressionKind[ExpressionKind["ResetView"] = 7] = "ResetView";
+    ExpressionKind[ExpressionKind["ResetView"] = 8] = "ResetView";
     /**
      * Defines and calls a function with change-detected arguments.
      */
-    ExpressionKind[ExpressionKind["PureFunctionExpr"] = 8] = "PureFunctionExpr";
+    ExpressionKind[ExpressionKind["PureFunctionExpr"] = 9] = "PureFunctionExpr";
     /**
      * Indicates a positional parameter to a pure function definition.
      */
-    ExpressionKind[ExpressionKind["PureFunctionParameterExpr"] = 9] = "PureFunctionParameterExpr";
+    ExpressionKind[ExpressionKind["PureFunctionParameterExpr"] = 10] = "PureFunctionParameterExpr";
     /**
      * Binding to a pipe transformation.
      */
-    ExpressionKind[ExpressionKind["PipeBinding"] = 10] = "PipeBinding";
+    ExpressionKind[ExpressionKind["PipeBinding"] = 11] = "PipeBinding";
     /**
      * Binding to a pipe transformation with a variable number of arguments.
      */
-    ExpressionKind[ExpressionKind["PipeBindingVariadic"] = 11] = "PipeBindingVariadic";
+    ExpressionKind[ExpressionKind["PipeBindingVariadic"] = 12] = "PipeBindingVariadic";
     /*
      * A safe property read requiring expansion into a null check.
      */
-    ExpressionKind[ExpressionKind["SafePropertyRead"] = 12] = "SafePropertyRead";
+    ExpressionKind[ExpressionKind["SafePropertyRead"] = 13] = "SafePropertyRead";
     /**
      * A safe keyed read requiring expansion into a null check.
      */
-    ExpressionKind[ExpressionKind["SafeKeyedRead"] = 13] = "SafeKeyedRead";
+    ExpressionKind[ExpressionKind["SafeKeyedRead"] = 14] = "SafeKeyedRead";
     /**
      * A safe function call requiring expansion into a null check.
      */
-    ExpressionKind[ExpressionKind["SafeInvokeFunction"] = 14] = "SafeInvokeFunction";
+    ExpressionKind[ExpressionKind["SafeInvokeFunction"] = 15] = "SafeInvokeFunction";
     /**
      * An intermediate expression that will be expanded from a safe read into an explicit ternary.
      */
-    ExpressionKind[ExpressionKind["SafeTernaryExpr"] = 15] = "SafeTernaryExpr";
+    ExpressionKind[ExpressionKind["SafeTernaryExpr"] = 16] = "SafeTernaryExpr";
     /**
      * An empty expression that will be stipped before generating the final output.
      */
-    ExpressionKind[ExpressionKind["EmptyExpr"] = 16] = "EmptyExpr";
+    ExpressionKind[ExpressionKind["EmptyExpr"] = 17] = "EmptyExpr";
     /*
      * An assignment to a temporary variable.
      */
-    ExpressionKind[ExpressionKind["AssignTemporaryExpr"] = 17] = "AssignTemporaryExpr";
+    ExpressionKind[ExpressionKind["AssignTemporaryExpr"] = 18] = "AssignTemporaryExpr";
     /**
      * A reference to a temporary variable.
      */
-    ExpressionKind[ExpressionKind["ReadTemporaryExpr"] = 18] = "ReadTemporaryExpr";
+    ExpressionKind[ExpressionKind["ReadTemporaryExpr"] = 19] = "ReadTemporaryExpr";
     /**
      * An expression representing a sanitizer function.
      */
-    ExpressionKind[ExpressionKind["SanitizerExpr"] = 19] = "SanitizerExpr";
+    ExpressionKind[ExpressionKind["SanitizerExpr"] = 20] = "SanitizerExpr";
     /**
      * An expression that will cause a literal slot index to be emitted.
      */
-    ExpressionKind[ExpressionKind["SlotLiteralExpr"] = 20] = "SlotLiteralExpr";
+    ExpressionKind[ExpressionKind["SlotLiteralExpr"] = 21] = "SlotLiteralExpr";
     /**
      * A test expression for a conditional op.
      */
-    ExpressionKind[ExpressionKind["ConditionalCase"] = 21] = "ConditionalCase";
+    ExpressionKind[ExpressionKind["ConditionalCase"] = 22] = "ConditionalCase";
+    /**
+     * A variable for use inside a repeater, providing one of the ambiently-available context
+     * properties ($even, $first, etc.).
+     */
+    ExpressionKind[ExpressionKind["DerivedRepeaterVar"] = 23] = "DerivedRepeaterVar";
 })(ExpressionKind || (ExpressionKind = {}));
+var VariableFlags;
+(function (VariableFlags) {
+    VariableFlags[VariableFlags["None"] = 0] = "None";
+    /**
+     * Always inline this variable, regardless of the number of times it's used.
+     * An `AlwaysInline` variable may not depend on context, because doing so may cause side effects
+     * that are illegal when multi-inlined. (The optimizer will enforce this constraint.)
+     */
+    VariableFlags[VariableFlags["AlwaysInline"] = 1] = "AlwaysInline";
+})(VariableFlags || (VariableFlags = {}));
 /**
  * Distinguishes between different kinds of `SemanticVariable`s.
  */
@@ -8966,6 +8994,10 @@ var SemanticVariableKind;
      * Represents a saved state that can be used to restore a view in a listener handler function.
      */
     SemanticVariableKind[SemanticVariableKind["SavedView"] = 2] = "SavedView";
+    /**
+     * An alias generated by a special embedded view type (e.g. a `@for` block).
+     */
+    SemanticVariableKind[SemanticVariableKind["Alias"] = 3] = "Alias";
 })(SemanticVariableKind || (SemanticVariableKind = {}));
 /**
  * Whether to compile in compatibilty mode. In compatibility mode, the template pipeline will
@@ -9161,12 +9193,13 @@ function createStatementOp(statement) {
 /**
  * Create a `VariableOp`.
  */
-function createVariableOp(xref, variable, initializer) {
+function createVariableOp(xref, variable, initializer, flags) {
     return {
         kind: OpKind.Variable,
         xref,
         variable,
         initializer,
+        flags,
         ...NEW_OP,
     };
 }
@@ -9343,6 +9376,16 @@ function createConditionalOp(target, test, conditions, sourceSpan) {
         ...TRAIT_CONSUMES_VARS,
     };
 }
+function createRepeaterOp(repeaterCreate, collection, sourceSpan) {
+    return {
+        kind: OpKind.Repeater,
+        target: repeaterCreate,
+        collection,
+        sourceSpan,
+        ...NEW_OP,
+        ...TRAIT_USES_SLOT_INDEX,
+    };
+}
 /**
  * Create an i18n expression op.
  */
@@ -9361,7 +9404,7 @@ function createI18nExpressionOp(owner, expression, i18nPlaceholder, resolutionTi
     };
 }
 /**
- * Creates an op to apply i18n expression ops.
+ *Creates an op to apply i18n expression ops
  */
 function createI18nApplyOp(target, sourceSpan) {
     return {
@@ -9409,8 +9452,11 @@ class LexicalReadExpr extends ExpressionBase {
         this.kind = ExpressionKind.LexicalRead;
     }
     visitExpression(visitor, context) { }
-    isEquivalent() {
-        return false;
+    isEquivalent(other) {
+        // We assume that the lexical reads are in the same context, which must be true for parent
+        // expressions to be equivalent.
+        // TODO: is this generally safe?
+        return this.name === other.name;
     }
     isConstant() {
         return false;
@@ -9468,6 +9514,27 @@ class ContextExpr extends ExpressionBase {
         return new ContextExpr(this.view);
     }
 }
+/**
+ * A reference to the current view context inside a track function.
+ */
+class TrackContextExpr extends ExpressionBase {
+    constructor(view) {
+        super();
+        this.view = view;
+        this.kind = ExpressionKind.TrackContext;
+    }
+    visitExpression() { }
+    isEquivalent(e) {
+        return e instanceof TrackContextExpr && e.view === this.view;
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions() { }
+    clone() {
+        return new TrackContextExpr(this.view);
+    }
+}
 /**
  * Runtime operation to navigate to the next view context in the view hierarchy.
  */
@@ -9985,6 +10052,33 @@ class ConditionalCaseExpr extends ExpressionBase {
         }
     }
 }
+var DerivedRepeaterVarIdentity;
+(function (DerivedRepeaterVarIdentity) {
+    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["First"] = 0] = "First";
+    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["Last"] = 1] = "Last";
+    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["Even"] = 2] = "Even";
+    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["Odd"] = 3] = "Odd";
+})(DerivedRepeaterVarIdentity || (DerivedRepeaterVarIdentity = {}));
+class DerivedRepeaterVarExpr extends ExpressionBase {
+    constructor(xref, identity) {
+        super();
+        this.xref = xref;
+        this.identity = identity;
+        this.kind = ExpressionKind.DerivedRepeaterVar;
+    }
+    transformInternalExpressions(transform, flags) { }
+    visitExpression(visitor, context) { }
+    isEquivalent(e) {
+        return e instanceof DerivedRepeaterVarExpr && e.identity === this.identity &&
+            e.xref === this.xref;
+    }
+    isConstant() {
+        return false;
+    }
+    clone() {
+        return new DerivedRepeaterVarExpr(this.xref, this.identity);
+    }
+}
 /**
  * Visits all `Expression`s in the AST of `op` with the `visitor` function.
  */
@@ -10079,6 +10173,15 @@ function transformExpressionsInOp(op, transform, flags) {
                 transformExpressionsInStatement(statement, transform, flags);
             }
             break;
+        case OpKind.RepeaterCreate:
+            op.track = transformExpressionsInExpression(op.track, transform, flags);
+            if (op.trackByFn !== null) {
+                op.trackByFn = transformExpressionsInExpression(op.trackByFn, transform, flags);
+            }
+            break;
+        case OpKind.Repeater:
+            op.collection = transformExpressionsInExpression(op.collection, transform, flags);
+            break;
         case OpKind.I18n:
         case OpKind.I18nStart:
             for (const [placeholder, expression] of op.params) {
@@ -10483,7 +10586,7 @@ class OpList {
  */
 const elementContainerOpKinds = new Set([
     OpKind.Element, OpKind.ElementStart, OpKind.Container, OpKind.ContainerStart, OpKind.Template,
-    OpKind.Projection
+    OpKind.RepeaterCreate
 ]);
 /**
  * Checks whether the given operation represents the creation of an element or container.
@@ -10530,6 +10633,28 @@ function createTemplateOp(xref, tag, namespace, generatedInBlock, i18nPlaceholde
         ...NEW_OP,
     };
 }
+function createRepeaterCreateOp(primaryView, emptyView, track, varNames, sourceSpan) {
+    return {
+        kind: OpKind.RepeaterCreate,
+        attributes: null,
+        xref: primaryView,
+        emptyView,
+        track,
+        trackByFn: null,
+        tag: 'For',
+        namespace: Namespace.HTML,
+        nonBindable: false,
+        localRefs: [],
+        decls: null,
+        vars: null,
+        varNames,
+        usesComponentInstance: false,
+        sourceSpan,
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+        numSlotsUsed: emptyView === null ? 2 : 3,
+    };
+}
 /**
  * Create an `ElementEndOp`.
  */
@@ -10620,16 +10745,15 @@ function createProjectionDefOp(def) {
         ...NEW_OP,
     };
 }
-function createProjectionOp(xref, selector) {
+function createProjectionOp(xref, selector, sourceSpan) {
     return {
         kind: OpKind.Projection,
         xref,
         selector,
         projectionSlotIndex: 0,
-        attributes: null,
+        attributes: [],
         localRefs: [],
-        nonBindable: false,
-        sourceSpan: null,
+        sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -10907,6 +11031,11 @@ class ViewCompilationUnit extends CompilationUnit {
          * which they alias.
          */
         this.contextVariables = new Map();
+        /**
+         * Set of aliases available within this view. An alias is a variable whose provided expression is
+         * inlined at every location it is used. It may also depend on context variables, by name.
+         */
+        this.aliases = new Set();
         /**
          * Number of declaration slots used within this view, or `null` if slots have not yet been
          * allocated.
@@ -10939,137 +11068,6 @@ class HostBindingCompilationUnit extends CompilationUnit {
     }
 }
 
-/**
- * Counts the number of variable slots used within each view, and stores that on the view itself, as
- * well as propagates it to the `ir.TemplateOp` for embedded views.
- */
-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;
-                }
-                // Some expressions require knowledge of the number of variable slots consumed.
-                if (hasUsesVarOffsetTrait(expr)) {
-                    expr.varOffset = varCount;
-                }
-                if (hasConsumesVarsTrait(expr)) {
-                    varCount += varsUsedByIrExpression(expr);
-                }
-            });
-        }
-        unit.vars = varCount;
-    }
-    if (job instanceof ComponentCompilationJob) {
-        // Add var counts for each view to the `ir.TemplateOp` which declares that view (if the view is
-        // an embedded view).
-        for (const unit of job.units) {
-            for (const op of unit.create) {
-                if (op.kind !== OpKind.Template) {
-                    continue;
-                }
-                const childView = job.views.get(op.xref);
-                op.vars = childView.vars;
-            }
-        }
-    }
-}
-/**
- * Different operations that implement `ir.UsesVarsTrait` use different numbers of variables, so
- * count the variables used by any particular `op`.
- */
-function varsUsedByOp(op) {
-    let slots;
-    switch (op.kind) {
-        case OpKind.Property:
-        case OpKind.HostProperty:
-        case OpKind.Attribute:
-            // All of these bindings use 1 variable slot, plus 1 slot for every interpolated expression,
-            // if any.
-            slots = 1;
-            if (op.expression instanceof Interpolation) {
-                slots += op.expression.expressions.length;
-            }
-            return slots;
-        case OpKind.StyleProp:
-        case OpKind.ClassProp:
-        case OpKind.StyleMap:
-        case OpKind.ClassMap:
-            // Style & class bindings use 2 variable slots, plus 1 slot for every interpolated expression,
-            // if any.
-            slots = 2;
-            if (op.expression instanceof Interpolation) {
-                slots += op.expression.expressions.length;
-            }
-            return slots;
-        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]}`);
-    }
-}
-function varsUsedByIrExpression(expr) {
-    switch (expr.kind) {
-        case ExpressionKind.PureFunctionExpr:
-            return 1 + expr.args.length;
-        case ExpressionKind.PipeBinding:
-            return 1 + expr.args.length;
-        case ExpressionKind.PipeBindingVariadic:
-            return 1 + expr.numArgs;
-        default:
-            throw new Error(`AssertionError: unhandled ConsumesVarsTrait expression ${expr.constructor.name}`);
-    }
-}
-
-function phaseAlignPipeVariadicVarOffset(job) {
-    for (const unit of job.units) {
-        for (const op of unit.update) {
-            visitExpressionsInOp(op, expr => {
-                if (!(expr instanceof PipeBindingVariadicExpr)) {
-                    return expr;
-                }
-                if (!(expr.args instanceof PureFunctionExpr)) {
-                    return expr;
-                }
-                if (expr.varOffset === null || expr.args.varOffset === null) {
-                    throw new Error(`Must run after variable counting`);
-                }
-                // The structure of this variadic pipe expression is:
-                // PipeBindingVariadic(#, Y, PureFunction(X, ...ARGS))
-                // Where X and Y are the slot offsets for the variables used by these operations, and Y > X.
-                // In `TemplateDefinitionBuilder` the PipeBindingVariadic variable slots are allocated
-                // before the PureFunction slots, which is unusually out-of-order.
-                //
-                // To maintain identical output for the tests in question, we adjust the variable offsets of
-                // these two calls to emulate TDB's behavior. This is not perfect, because the ARGS of the
-                // PureFunction call may also allocate slots which by TDB's ordering would come after X, and
-                // we don't account for that. Still, this should be enough to pass the existing pipe tests.
-                // Put the PipeBindingVariadic vars where the PureFunction vars were previously allocated.
-                expr.varOffset = expr.args.varOffset;
-                // Put the PureFunction vars following the PipeBindingVariadic vars.
-                expr.args.varOffset = expr.varOffset + varsUsedByIrExpression(expr);
-                return undefined;
-            });
-        }
-    }
-}
-
 /**
  * Find any function calls to `$any`, excluding `this.$any`, and delete them.
  */
@@ -11145,18 +11143,41 @@ function phaseAssignI18nSlotDependencies(job) {
     }
 }
 
+/**
+ * Attribute interpolations of the form `[attr.foo]="{{foo}}""` should be "collapsed" into a plain
+ * attribute instruction, instead of an `attributeInterpolate` instruction.
+ *
+ * (We cannot do this for singleton property interpolations, because `propertyInterpolate`
+ * stringifies its expression.)
+ *
+ * The reification step is also capable of performing this transformation, but doing it early in the
+ * pipeline allows other phases to accurately know what instruction will be emitted.
+ */
+function phaseCollapseSingletonInterpolations(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            const eligibleOpKind = op.kind === OpKind.Attribute;
+            if (eligibleOpKind && op.expression instanceof Interpolation &&
+                op.expression.strings.length === 2 &&
+                op.expression.strings.every((s) => s === '')) {
+                op.expression = op.expression.expressions[0];
+            }
+        }
+    }
+}
+
 /**
  * Gets a map of all elements in the given view by their xref id.
  */
-function getElementsByXrefId(unit) {
-    const elements = new Map();
+function createOpXrefMap(unit) {
+    const map = new Map();
     for (const op of unit.create) {
-        if (!isElementOrContainerOp(op)) {
+        if (!hasConsumesSlotTrait(op)) {
             continue;
         }
-        elements.set(op.xref, op);
+        map.set(op.xref, op);
     }
-    return elements;
+    return map;
 }
 
 /**
@@ -11165,7 +11186,7 @@ function getElementsByXrefId(unit) {
  */
 function phaseAttributeExtraction(job) {
     for (const unit of job.units) {
-        const elements = getElementsByXrefId(unit);
+        const elements = createOpXrefMap(unit);
         for (const op of unit.ops()) {
             switch (op.kind) {
                 case OpKind.Attribute:
@@ -11173,7 +11194,7 @@ function phaseAttributeExtraction(job) {
                     break;
                 case OpKind.Property:
                     if (!op.isAnimationTrigger) {
-                        OpList.insertBefore(createExtractedAttributeOp(op.target, op.isTemplate ? BindingKind.Template : BindingKind.Property, op.name, null), lookupElement$3(elements, op.target));
+                        OpList.insertBefore(createExtractedAttributeOp(op.target, op.isTemplate ? BindingKind.Template : BindingKind.Property, op.name, null), lookupElement$2(elements, op.target));
                     }
                     break;
                 case OpKind.StyleProp:
@@ -11183,7 +11204,7 @@ function phaseAttributeExtraction(job) {
                     // mode.
                     if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder &&
                         op.expression instanceof EmptyExpr) {
-                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, op.name, null), lookupElement$3(elements, op.target));
+                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, op.name, null), lookupElement$2(elements, op.target));
                     }
                     break;
                 case OpKind.Listener:
@@ -11195,7 +11216,7 @@ function phaseAttributeExtraction(job) {
                             unit.create.push(extractedAttributeOp);
                         }
                         else {
-                            OpList.insertBefore(extractedAttributeOp, lookupElement$3(elements, op.target));
+                            OpList.insertBefore(extractedAttributeOp, lookupElement$2(elements, op.target));
                         }
                     }
                     break;
@@ -11206,7 +11227,7 @@ function phaseAttributeExtraction(job) {
 /**
  * Looks up an element in the given map by xref ID.
  */
-function lookupElement$3(elements, xref) {
+function lookupElement$2(elements, xref) {
     const el = elements.get(xref);
     if (el === undefined) {
         throw new Error('All attributes should have an element-like target.');
@@ -11244,7 +11265,7 @@ function extractAttributeOp(unit, op, elements) {
             unit.create.push(extractedAttributeOp);
         }
         else {
-            const ownerOp = lookupElement$3(elements, op.target);
+            const ownerOp = lookupElement$2(elements, op.target);
             OpList.insertBefore(extractedAttributeOp, ownerOp);
         }
         OpList.remove(op);
@@ -11254,7 +11275,7 @@ function extractAttributeOp(unit, op, elements) {
 /**
  * Looks up an element in the given map by xref ID.
  */
-function lookupElement$2(elements, xref) {
+function lookupElement$1(elements, xref) {
     const el = elements.get(xref);
     if (el === undefined) {
         throw new Error('All attributes should have an element-like target.');
@@ -11280,7 +11301,7 @@ function phaseBindingSpecialization(job) {
                 case BindingKind.Attribute:
                     if (op.name === 'ngNonBindable') {
                         OpList.remove(op);
-                        const target = lookupElement$2(elements, op.target);
+                        const target = lookupElement$1(elements, op.target);
                         target.nonBindable = true;
                     }
                     else {
@@ -11440,6 +11461,9 @@ function phaseConditionals(job) {
             }
             // Save the resulting aggregate Joost-expression.
             op.processed = test;
+            // Clear the original conditions array, since we no longer need it, and don't want it to
+            // affect subsequent phases (e.g. pipe creation).
+            op.conditions = [];
         }
     }
 }
@@ -11891,6 +11915,37 @@ function ternaryTransform(e) {
     return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
 }
 
+function phaseRepeaterDerivedVars(job) {
+    const repeaters = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            if (op.kind === OpKind.RepeaterCreate) {
+                repeaters.set(op.xref, op);
+            }
+        }
+    }
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            transformExpressionsInOp(op, expr => {
+                if (!(expr instanceof DerivedRepeaterVarExpr)) {
+                    return expr;
+                }
+                const repeaterOp = repeaters.get(expr.xref);
+                switch (expr.identity) {
+                    case DerivedRepeaterVarIdentity.First:
+                        return new BinaryOperatorExpr(BinaryOperator.Identical, new LexicalReadExpr(repeaterOp.varNames.$index), literal(0));
+                    case DerivedRepeaterVarIdentity.Last:
+                        return new BinaryOperatorExpr(BinaryOperator.Identical, new LexicalReadExpr(repeaterOp.varNames.$index), new BinaryOperatorExpr(BinaryOperator.Minus, new LexicalReadExpr(repeaterOp.varNames.$count), literal(1)));
+                    case DerivedRepeaterVarIdentity.Even:
+                        return new BinaryOperatorExpr(BinaryOperator.Identical, new BinaryOperatorExpr(BinaryOperator.Modulo, new LexicalReadExpr(repeaterOp.varNames.$index), literal(2)), literal(0));
+                    case DerivedRepeaterVarIdentity.Odd:
+                        return new BinaryOperatorExpr(BinaryOperator.NotIdentical, new BinaryOperatorExpr(BinaryOperator.Modulo, new LexicalReadExpr(repeaterOp.varNames.$index), literal(2)), literal(0));
+                }
+            }, VisitorContextFlag.None);
+        }
+    }
+}
+
 /**
  * Generate `ir.AdvanceOp`s in between `ir.UpdateOp`s that ensure the runtime's implicit slot
  * context will be advanced correctly.
@@ -12005,6 +12060,7 @@ function recursivelyProcessView(view, parentScope) {
     for (const op of view.create) {
         switch (op.kind) {
             case OpKind.Template:
+            case OpKind.RepeaterCreate:
                 // Descend into child embedded views.
                 recursivelyProcessView(view.job.views.get(op.xref), scope);
                 break;
@@ -12031,6 +12087,7 @@ function getScopeForView(view, parent) {
             view: view.xref,
         },
         contextVariables: new Map(),
+        aliases: view.aliases,
         references: [],
         parent,
     };
@@ -12078,19 +12135,23 @@ function generateVariablesInScopeForView(view, scope) {
         // Before generating variables for a parent view, we need to switch to the context of the parent
         // view with a `nextContext` expression. This context switching operation itself declares a
         // variable, because the context of the view may be referenced directly.
-        newOps.push(createVariableOp(view.job.allocateXrefId(), scope.viewContextVariable, new NextContextExpr()));
+        newOps.push(createVariableOp(view.job.allocateXrefId(), scope.viewContextVariable, new NextContextExpr(), VariableFlags.None));
     }
     // Add variables for all context variables available in this scope's view.
-    for (const [name, value] of view.job.views.get(scope.view).contextVariables) {
+    const scopeView = view.job.views.get(scope.view);
+    for (const [name, value] of scopeView.contextVariables) {
         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));
+        newOps.push(createVariableOp(view.job.allocateXrefId(), scope.contextVariables.get(name), variable, VariableFlags.None));
+    }
+    for (const alias of scopeView.aliases) {
+        newOps.push(createVariableOp(view.job.allocateXrefId(), alias, alias.expression.clone(), VariableFlags.AlwaysInline));
     }
     // Add variables for all local references declared for elements in this scope.
     for (const ref of scope.references) {
-        newOps.push(createVariableOp(view.job.allocateXrefId(), ref.variable, new ReferenceExpr(ref.targetId, ref.offset)));
+        newOps.push(createVariableOp(view.job.allocateXrefId(), ref.variable, new ReferenceExpr(ref.targetId, ref.offset), VariableFlags.None));
     }
     if (scope.parent !== null) {
         // Recursively add variables from the parent scope.
@@ -13972,11 +14033,12 @@ class Comment {
     }
 }
 class Block {
-    constructor(name, parameters, children, sourceSpan, startSourceSpan, endSourceSpan = null) {
+    constructor(name, parameters, children, sourceSpan, nameSpan, startSourceSpan, endSourceSpan = null) {
         this.name = name;
         this.parameters = parameters;
         this.children = children;
         this.sourceSpan = sourceSpan;
+        this.nameSpan = nameSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
     }
@@ -17790,7 +17852,7 @@ class _Tokenizer {
             }
         }
         if (this._tokenizeBlocks && !this._inInterpolation && !this._isInExpansion() &&
-            (this._isBlockStart() || this._cursor.peek() === $RBRACE)) {
+            (this._cursor.peek() === $AT || this._cursor.peek() === $RBRACE)) {
             return true;
         }
         return false;
@@ -17813,17 +17875,6 @@ class _Tokenizer {
         }
         return false;
     }
-    _isBlockStart() {
-        if (this._tokenizeBlocks && this._cursor.peek() === $AT) {
-            const tmp = this._cursor.clone();
-            // If it is, also verify that the next character is a valid block identifier.
-            tmp.advance();
-            if (isBlockNameChar(tmp.peek())) {
-                return true;
-            }
-        }
-        return false;
-    }
     _readUntil(char) {
         const start = this._cursor.clone();
         this._attemptUntilChar(char);
@@ -18530,7 +18581,7 @@ class _TreeBuilder {
         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);
+        const block = new Block(token.parts[0], parameters, [], span, token.sourceSpan, startSpan);
         this._pushContainer(block, false);
     }
     _consumeBlockClose(token) {
@@ -18550,7 +18601,7 @@ class _TreeBuilder {
         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);
+        const block = new Block(token.parts[0], parameters, [], span, token.sourceSpan, 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);
@@ -19476,6 +19527,22 @@ function addNamesToView(unit, baseName, state, compatibility) {
             case OpKind.Variable:
                 varNames.set(op.xref, getVariableName(op.variable, state));
                 break;
+            case OpKind.RepeaterCreate:
+                if (!(unit instanceof ViewCompilationUnit)) {
+                    throw new Error(`AssertionError: must be compiling a component`);
+                }
+                if (op.slot === null) {
+                    throw new Error(`Expected slot to be assigned`);
+                }
+                if (op.emptyView !== null) {
+                    const emptyView = unit.job.views.get(op.emptyView);
+                    // Repeater empty view function is at slot +2 (metadata is in the first slot).
+                    addNamesToView(emptyView, `${baseName}_${prefixWithNamespace(`${op.tag}Empty`, op.namespace)}_${op.slot + 2}`, state, compatibility);
+                }
+                const repeaterToken = op.tag === null ? '' : '_' + prefixWithNamespace(op.tag, op.namespace);
+                // Repeater primary view function is at slot +1 (metadata is in the first slot).
+                addNamesToView(unit.job.views.get(op.xref), `${baseName}${repeaterToken}_${op.slot + 1}`, state, compatibility);
+                break;
             case OpKind.Template:
                 if (!(unit instanceof ViewCompilationUnit)) {
                     throw new Error(`AssertionError: must be compiling a component`);
@@ -19521,10 +19588,12 @@ function getVariableName(variable, state) {
                 variable.name = `ctx_r${state.index++}`;
                 break;
             case SemanticVariableKind.Identifier:
-                variable.name = `${variable.identifier}_${state.index++}`;
+                // TODO: Prefix increment and `_r` for compatiblity only.
+                variable.name = `${variable.identifier}_r${++state.index}`;
                 break;
             default:
-                variable.name = `_r${state.index++}`;
+                // TODO: Prefix increment for compatibility only.
+                variable.name = `_r${++state.index}`;
                 break;
         }
     }
@@ -19635,7 +19704,7 @@ function phaseNgContainer(job) {
 /**
  * Looks up an element in the given map by xref ID.
  */
-function lookupElement$1(elements, xref) {
+function lookupElement(elements, xref) {
     const el = elements.get(xref);
     if (el === undefined) {
         throw new Error('All attributes should have an element-like target.');
@@ -19664,7 +19733,7 @@ function phaseNonbindable(job) {
                 OpList.insertAfter(createDisableBindingsOp(op.xref), op);
             }
             if ((op.kind === OpKind.ElementEnd || op.kind === OpKind.ContainerEnd) &&
-                lookupElement$1(elements, op.xref).nonBindable) {
+                lookupElement(elements, op.xref).nonBindable) {
                 OpList.insertBefore(createEnableBindingsOp(op.xref), op);
             }
         }
@@ -19692,9 +19761,14 @@ function phaseNullishCoalescing(job) {
 function kindTest(kind) {
     return (op) => op.kind === kind;
 }
+function kindWithInterpolationTest(kind, interpolation) {
+    return (op) => {
+        return op.kind === kind && interpolation === op.expression instanceof Interpolation;
+    };
+}
 /**
  * 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
+ * op kinds. Ops will be collected into groups, then optionally transformed, before recombining
  * the groups in the order defined here.
  */
 const CREATE_ORDERING = [
@@ -19702,18 +19776,20 @@ const CREATE_ORDERING = [
     { test: op => op.kind === OpKind.Listener && !(op.hostListener && op.isAnimationListener) },
 ];
 /**
- * As above, but for update ops.
+ * Defines the groups based on `OpKind` that ops will be divided into, for the various update
+ * op kinds.
  */
 const UPDATE_ORDERING = [
-    { test: op => op.kind === OpKind.HostProperty && op.expression instanceof Interpolation },
-    { test: op => op.kind === OpKind.HostProperty && !(op.expression instanceof Interpolation) },
+    { test: kindWithInterpolationTest(OpKind.HostProperty, true) },
+    { test: kindWithInterpolationTest(OpKind.HostProperty, false) },
     { 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) },
+    { test: kindWithInterpolationTest(OpKind.Property, true) },
+    { test: kindWithInterpolationTest(OpKind.Attribute, true) },
+    { test: kindWithInterpolationTest(OpKind.Property, false) },
+    { test: kindWithInterpolationTest(OpKind.Attribute, false) },
 ];
 /**
  * The set of all op kinds we handle in the reordering phase.
@@ -19728,32 +19804,34 @@ function phaseOrdering(job) {
         // 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));
+        orderWithin(unit.create, 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 = [];
-            }
+        orderWithin(unit.update, UPDATE_ORDERING);
+    }
+}
+/**
+ * Order all the ops within the specified group.
+ */
+function orderWithin(opList, ordering) {
+    let opsToOrder = [];
+    // Only reorder ops that target the same xref; do not mix ops that target different xrefs.
+    let firstTargetInGroup = null;
+    for (const op of opList) {
+        const currentTarget = hasDependsOnSlotContextTrait(op) ? op.target : null;
+        if (!handledOpKinds.has(op.kind) ||
+            (currentTarget !== firstTargetInGroup &&
+                (firstTargetInGroup !== null && currentTarget !== null))) {
+            OpList.insertBefore(reorder(opsToOrder, ordering), op);
+            opsToOrder = [];
+            firstTargetInGroup = null;
+        }
+        if (handledOpKinds.has(op.kind)) {
+            opsToOrder.push(op);
+            OpList.remove(op);
+            firstTargetInGroup = currentTarget ?? firstTargetInGroup;
         }
-        unit.update.push(reorder(opsToOrder, UPDATE_ORDERING));
     }
+    opList.push(reorder(opsToOrder, ordering));
 }
 /**
  * Reorders the given list of ops according to the ordering defined by `ORDERING`.
@@ -19812,15 +19890,15 @@ function phaseParseExtractedStyles(cpl) {
  */
 function phaseRemoveContentSelectors(job) {
     for (const unit of job.units) {
-        const elements = getElementsByXrefId(unit);
+        const elements = createOpXrefMap(unit);
         for (const op of unit.update) {
             switch (op.kind) {
                 case OpKind.Binding:
-                    const target = lookupElement(elements, op.target);
+                    const target = lookupInXrefMap(elements, op.target);
                     if (op.name.toLowerCase() === 'select' && target.kind === OpKind.Projection) {
                         OpList.remove(op);
                     }
-                    continue;
+                    break;
             }
         }
     }
@@ -19828,10 +19906,10 @@ function phaseRemoveContentSelectors(job) {
 /**
  * Looks up an element in the given map by xref ID.
  */
-function lookupElement(elements, xref) {
-    const el = elements.get(xref);
+function lookupInXrefMap(map, xref) {
+    const el = map.get(xref);
     if (el === undefined) {
-        throw new Error('All attributes should have an element-like target.');
+        throw new Error('All attributes should have an slottable target.');
     }
     return el;
 }
@@ -19853,10 +19931,22 @@ function processPipeBindingsInView(unit) {
             if (flags & VisitorContextFlag.InChildOperation) {
                 throw new Error(`AssertionError: pipe bindings should not appear in child expressions`);
             }
-            if (!hasDependsOnSlotContextTrait(updateOp)) {
+            // This update op must be associated with a create op that consumes a slot (either by
+            // depending on the ambient context of `target`, or merely referencing that create op via
+            // `target`).
+            if (!hasDependsOnSlotContextTrait(updateOp) &&
+                !hasUsesSlotIndexTrait(updateOp)) {
                 throw new Error(`AssertionError: pipe binding associated with non-slot operation ${OpKind[updateOp.kind]}`);
             }
-            addPipeToCreationBlock(unit, updateOp.target, expr);
+            if (unit.job.compatibility) {
+                addPipeToCreationBlock(unit, updateOp.target, expr);
+            }
+            else {
+                // When not in compatibility mode, we just add the pipe to the end of the create block. This
+                // is not only simpler and faster, but allows more chaining opportunities for other
+                // instructions.
+                unit.create.push(createPipeOp(expr.target, expr.name));
+            }
         });
     }
 }
@@ -19978,6 +20068,7 @@ class PureFunctionConstant extends GenericKeyFn {
             return super.keyOf(expr);
         }
     }
+    // TODO: Use the new pool method `getSharedFunctionReference`
     toSharedConstantDeclaration(declName, keyExpr) {
         const fnParams = [];
         for (let idx = 0; idx < this.numArgs; idx++) {
@@ -20177,15 +20268,15 @@ function deferOn(sourceSpan) {
 function projectionDef(def) {
     return call(Identifiers.projectionDef, def ? [def] : [], null);
 }
-function projection(slot, projectionSlotIndex, attributes) {
+function projection(slot, projectionSlotIndex, attributes, sourceSpan) {
     const args = [literal(slot)];
-    if (projectionSlotIndex !== 0 || attributes !== null) {
+    if (projectionSlotIndex !== 0 || attributes.length > 0) {
         args.push(literal(projectionSlotIndex));
-        if (attributes != null) {
-            args.push(literal(attributes));
+        if (attributes.length > 0) {
+            args.push(literalArr(attributes.map(attr => literal(attr))));
         }
     }
-    return call(Identifiers.projection, args, null);
+    return call(Identifiers.projection, args, sourceSpan);
 }
 function i18nStart(slot, constIndex, subTemplateIndex) {
     const args = [literal(slot), literal(constIndex)];
@@ -20194,6 +20285,27 @@ function i18nStart(slot, constIndex, subTemplateIndex) {
     }
     return call(Identifiers.i18nStart, args, null);
 }
+function repeaterCreate(slot, viewFnName, decls, vars, trackByFn, trackByUsesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, sourceSpan) {
+    let args = [
+        literal(slot),
+        variable(viewFnName),
+        literal(decls),
+        literal(vars),
+        trackByFn,
+    ];
+    if (trackByUsesComponentInstance || emptyViewFnName !== null) {
+        args.push(literal(trackByUsesComponentInstance));
+        if (emptyViewFnName !== null) {
+            args.push(variable(emptyViewFnName));
+            args.push(literal(emptyDecls));
+            args.push(literal(emptyVars));
+        }
+    }
+    return call(Identifiers.repeaterCreate, args, sourceSpan);
+}
+function repeater(metadataSlot, collection, sourceSpan) {
+    return call(Identifiers.repeater, [literal(metadataSlot), collection], sourceSpan);
+}
 function i18n(slot, constIndex, subTemplateIndex) {
     const args = [literal(slot), literal(constIndex)];
     if (subTemplateIndex) {
@@ -20648,7 +20760,35 @@ function reifyCreateOperations(unit, ops) {
                 if (op.slot === null) {
                     throw new Error('No slot was assigned for project instruction');
                 }
-                OpList.replace(op, projection(op.slot, op.projectionSlotIndex, op.attributes));
+                OpList.replace(op, projection(op.slot, op.projectionSlotIndex, op.attributes, op.sourceSpan));
+                break;
+            case OpKind.RepeaterCreate:
+                if (op.slot === null) {
+                    throw new Error('No slot was assigned for repeater instruction');
+                }
+                if (!(unit instanceof ViewCompilationUnit)) {
+                    throw new Error(`AssertionError: must be compiling a component`);
+                }
+                const repeaterView = unit.job.views.get(op.xref);
+                if (repeaterView.fnName === null) {
+                    throw new Error(`AssertionError: expected repeater primary view to have been named`);
+                }
+                let emptyViewFnName = null;
+                let emptyDecls = null;
+                let emptyVars = null;
+                if (op.emptyView !== null) {
+                    const emptyView = unit.job.views.get(op.emptyView);
+                    if (emptyView === undefined) {
+                        throw new Error('AssertionError: repeater had empty view xref, but empty view was not found');
+                    }
+                    if (emptyView.fnName === null || emptyView.decls === null || emptyView.vars === null) {
+                        throw new Error(`AssertionError: expected repeater empty view to have been named and counted`);
+                    }
+                    emptyViewFnName = emptyView.fnName;
+                    emptyDecls = emptyView.decls;
+                    emptyVars = emptyView.vars;
+                }
+                OpList.replace(op, repeaterCreate(op.slot, repeaterView.fnName, op.decls, op.vars, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.sourceSpan));
                 break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
@@ -20745,6 +20885,9 @@ function reifyUpdateOperations(_unit, ops) {
                 }
                 OpList.replace(op, conditional(op.targetSlot, op.processed, op.contextValue, op.sourceSpan));
                 break;
+            case OpKind.Repeater:
+                OpList.replace(op, repeater(op.targetSlot, op.collection, op.sourceSpan));
+                break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
                 break;
@@ -20883,6 +21026,10 @@ function processLexicalScope$1(view, ops) {
                 break;
         }
     }
+    if (view === view.job.root) {
+        // Prefer `ctx` of the root view to any variables which happen to contain the root context.
+        scope.set(view.xref, variable('ctx'));
+    }
     for (const op of ops) {
         transformExpressionsInOp(op, expr => {
             if (expr instanceof ContextExpr) {
@@ -21229,6 +21376,7 @@ function processLexicalScope(unit, ops, savedView) {
             case OpKind.Variable:
                 switch (op.variable.kind) {
                     case SemanticVariableKind.Identifier:
+                    case SemanticVariableKind.Alias:
                         // This variable represents some kind of identifier which can be used in the template.
                         if (scope.has(op.variable.identifier)) {
                             continue;
@@ -21311,7 +21459,7 @@ const sanitizers = new Map([
  */
 function phaseResolveSanitizers(job) {
     for (const unit of job.units) {
-        const elements = getElementsByXrefId(unit);
+        const elements = createOpXrefMap(unit);
         let sanitizerFn;
         for (const op of unit.update) {
             switch (op.kind) {
@@ -21325,7 +21473,7 @@ function phaseResolveSanitizers(job) {
                     // <iframe>).
                     if (op.sanitizer === null) {
                         const ownerOp = elements.get(op.target);
-                        if (ownerOp === undefined) {
+                        if (ownerOp === undefined || !isElementOrContainerOp(ownerOp)) {
                             throw Error('Property should have an element-like owner');
                         }
                         if (isIframeElement$1(ownerOp) && isIframeSecuritySensitiveAttr(op.name)) {
@@ -21351,7 +21499,7 @@ function phaseSaveRestoreView(job) {
                 kind: SemanticVariableKind.SavedView,
                 name: null,
                 view: view.xref,
-            }, new GetCurrentViewExpr()),
+            }, new GetCurrentViewExpr(), VariableFlags.None),
         ]);
         for (const op of view.create) {
             if (op.kind !== OpKind.Listener) {
@@ -21381,7 +21529,7 @@ function addSaveRestoreViewOperationToListener(unit, op) {
             kind: SemanticVariableKind.Context,
             name: null,
             view: unit.xref,
-        }, new RestoreViewExpr(unit.xref)),
+        }, new RestoreViewExpr(unit.xref), VariableFlags.None),
     ]);
     // The "restore view" operation in listeners requires a call to `resetView` to reset the
     // context prior to returning from the listener operation. Find any `return` statements in
@@ -21436,13 +21584,13 @@ function phaseSlotAllocation(job) {
     // propagate the number of slots used for each view into the operation which declares it.
     for (const unit of job.units) {
         for (const op of unit.ops()) {
-            if (op.kind === OpKind.Template) {
+            if (op.kind === OpKind.Template || op.kind === OpKind.RepeaterCreate) {
                 // Record the number of slots used by the view this `ir.TemplateOp` declares in the
                 // operation itself, so it can be emitted later.
                 const childView = job.views.get(op.xref);
                 op.decls = childView.decls;
             }
-            if (hasUsesSlotIndexTrait(op) && op.targetSlot === null) {
+            if (hasUsesSlotIndexTrait(op) && op.target !== null && 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}`);
@@ -21584,6 +21732,137 @@ function assignName(names, expr) {
     expr.name = name;
 }
 
+/**
+ * Counts the number of variable slots used within each view, and stores that on the view itself, as
+ * well as propagates it to the `ir.TemplateOp` for embedded views.
+ */
+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;
+                }
+                // TemplateDefinitionBuilder assigns variable offsets for everything but pure functions
+                // first, and then assigns offsets to pure functions lazily. We emulate that behavior by
+                // assigning offsets in two passes instead of one, only in compatibility mode.
+                if (job.compatibility === CompatibilityMode.TemplateDefinitionBuilder &&
+                    expr instanceof PureFunctionExpr) {
+                    return;
+                }
+                // Some expressions require knowledge of the number of variable slots consumed.
+                if (hasUsesVarOffsetTrait(expr)) {
+                    expr.varOffset = varCount;
+                }
+                if (hasConsumesVarsTrait(expr)) {
+                    varCount += varsUsedByIrExpression(expr);
+                }
+            });
+        }
+        // Compatiblity mode pass for pure function offsets (as explained above).
+        if (job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
+            for (const op of unit.ops()) {
+                visitExpressionsInOp(op, expr => {
+                    if (!isIrExpression(expr) || !(expr instanceof PureFunctionExpr)) {
+                        return;
+                    }
+                    // Some expressions require knowledge of the number of variable slots consumed.
+                    if (hasUsesVarOffsetTrait(expr)) {
+                        expr.varOffset = varCount;
+                    }
+                    if (hasConsumesVarsTrait(expr)) {
+                        varCount += varsUsedByIrExpression(expr);
+                    }
+                });
+            }
+        }
+        unit.vars = varCount;
+    }
+    if (job instanceof ComponentCompilationJob) {
+        // Add var counts for each view to the `ir.TemplateOp` which declares that view (if the view is
+        // an embedded view).
+        for (const unit of job.units) {
+            for (const op of unit.create) {
+                if (op.kind !== OpKind.Template && op.kind !== OpKind.RepeaterCreate) {
+                    continue;
+                }
+                const childView = job.views.get(op.xref);
+                op.vars = childView.vars;
+            }
+        }
+    }
+}
+/**
+ * Different operations that implement `ir.UsesVarsTrait` use different numbers of variables, so
+ * count the variables used by any particular `op`.
+ */
+function varsUsedByOp(op) {
+    let slots;
+    switch (op.kind) {
+        case OpKind.Property:
+        case OpKind.HostProperty:
+        case OpKind.Attribute:
+            // All of these bindings use 1 variable slot, plus 1 slot for every interpolated expression,
+            // if any.
+            slots = 1;
+            if (op.expression instanceof Interpolation && !isSingletonInterpolation(op.expression)) {
+                slots += op.expression.expressions.length;
+            }
+            return slots;
+        case OpKind.StyleProp:
+        case OpKind.ClassProp:
+        case OpKind.StyleMap:
+        case OpKind.ClassMap:
+            // Style & class bindings use 2 variable slots, plus 1 slot for every interpolated expression,
+            // if any.
+            slots = 2;
+            if (op.expression instanceof Interpolation) {
+                slots += op.expression.expressions.length;
+            }
+            return slots;
+        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]}`);
+    }
+}
+function varsUsedByIrExpression(expr) {
+    switch (expr.kind) {
+        case ExpressionKind.PureFunctionExpr:
+            return 1 + expr.args.length;
+        case ExpressionKind.PipeBinding:
+            return 1 + expr.args.length;
+        case ExpressionKind.PipeBindingVariadic:
+            return 1 + expr.numArgs;
+        default:
+            throw new Error(`AssertionError: unhandled ConsumesVarsTrait expression ${expr.constructor.name}`);
+    }
+}
+function isSingletonInterpolation(expr) {
+    if (expr.expressions.length !== 1 || expr.strings.length !== 2) {
+        return false;
+    }
+    if (expr.strings[0] !== '' || expr.strings[1] !== '') {
+        return false;
+    }
+    return true;
+}
+
 /**
  * Optimize variables declared and used in the IR.
  *
@@ -21604,6 +21883,13 @@ function assignName(names, expr) {
  */
 function phaseVariableOptimization(job) {
     for (const unit of job.units) {
+        inlineAlwaysInlineVariables(unit.create);
+        inlineAlwaysInlineVariables(unit.update);
+        for (const op of unit.create) {
+            if (op.kind === OpKind.Listener) {
+                inlineAlwaysInlineVariables(op.handlerOps);
+            }
+        }
         optimizeVariablesInOpList(unit.create, job.compatibility);
         optimizeVariablesInOpList(unit.update, job.compatibility);
         for (const op of unit.create) {
@@ -21646,6 +21932,30 @@ var Fence;
      */
     Fence[Fence["SideEffectful"] = 4] = "SideEffectful";
 })(Fence || (Fence = {}));
+function inlineAlwaysInlineVariables(ops) {
+    const vars = new Map();
+    for (const op of ops) {
+        if (op.kind === OpKind.Variable && op.flags & VariableFlags.AlwaysInline) {
+            visitExpressionsInOp(op, expr => {
+                if (isIrExpression(expr) && fencesForIrExpression(expr) !== Fence.None) {
+                    throw new Error(`AssertionError: A context-sensitive variable was marked AlwaysInline`);
+                }
+            });
+            vars.set(op.xref, op);
+        }
+        transformExpressionsInOp(op, expr => {
+            if (expr instanceof ReadVariableExpr && vars.has(expr.xref)) {
+                const varOp = vars.get(expr.xref);
+                // Inline by cloning, because we might inline into multiple places.
+                return varOp.initializer.clone();
+            }
+            return expr;
+        }, VisitorContextFlag.None);
+    }
+    for (const op of vars.values()) {
+        OpList.remove(op);
+    }
+}
 /**
  * Process a list of operations and optimize variables within that list.
  */
@@ -21715,10 +22025,15 @@ function optimizeVariablesInOpList(ops, compatibility) {
     // Next, inline any remaining variables with exactly one usage.
     const toInline = [];
     for (const [id, count] of varUsages) {
+        const decl = varDecls.get(id);
+        const varInfo = opMap.get(decl);
         // We can inline variables that:
-        //  - are used once
+        //  - are used exactly once, and
         //  - are not used remotely
-        if (count !== 1) {
+        // OR
+        //  - are marked for always inlining
+        const isAlwaysInline = !!(decl.flags & VariableFlags.AlwaysInline);
+        if (count !== 1 || isAlwaysInline) {
             // We can't inline this variable as it's used more than once.
             continue;
         }
@@ -21734,6 +22049,10 @@ function optimizeVariablesInOpList(ops, compatibility) {
         // no future operation will make inlining legal.
         const decl = varDecls.get(candidate);
         const varInfo = opMap.get(decl);
+        const isAlwaysInline = !!(decl.flags & VariableFlags.AlwaysInline);
+        if (isAlwaysInline) {
+            throw new Error(`AssertionError: Found an 'AlwaysInline' variable after the always inlining pass.`);
+        }
         // Scan operations following the variable declaration and look for the point where that variable
         // is used. There should only be one usage given the precondition above.
         for (let targetOp = decl.next; targetOp.kind !== OpKind.ListEnd; targetOp = targetOp.next) {
@@ -21981,6 +22300,141 @@ function phaseWrapIcus(job) {
     }
 }
 
+function phaseTrackVariables(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind !== OpKind.RepeaterCreate) {
+                continue;
+            }
+            op.track = transformExpressionsInExpression(op.track, expr => {
+                if (expr instanceof LexicalReadExpr) {
+                    if (expr.name === op.varNames.$index) {
+                        return variable('$index');
+                    }
+                    else if (expr.name === op.varNames.$implicit) {
+                        return variable('$item');
+                    }
+                    // TODO: handle prohibited context variables (emit as globals?)
+                }
+                return expr;
+            }, VisitorContextFlag.None);
+        }
+    }
+}
+
+/**
+ * Generate track functions that need to be extracted to the constant pool. This entails wrapping
+ * them in an arrow (or traditional) function, replacing context reads with `this.`, and storing
+ * them in the constant pool.
+ *
+ * Note that, if a track function was previously optimized, it will not need to be extracted, and
+ * this phase is a no-op.
+ */
+function phaseTrackFnGeneration(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind !== OpKind.RepeaterCreate) {
+                continue;
+            }
+            if (op.trackByFn !== null) {
+                // The final track function was already set, probably because it was optimized.
+                continue;
+            }
+            // Find all component context reads.
+            let usesComponentContext = false;
+            op.track = transformExpressionsInExpression(op.track, expr => {
+                if (expr instanceof TrackContextExpr) {
+                    usesComponentContext = true;
+                    return variable('this');
+                }
+                return expr;
+            }, VisitorContextFlag.None);
+            let fn;
+            const fnParams = [new FnParam('$index'), new FnParam('$item')];
+            if (usesComponentContext) {
+                fn = new FunctionExpr(fnParams, [new ReturnStatement(op.track)]);
+            }
+            else {
+                fn = arrowFn(fnParams, op.track);
+            }
+            op.trackByFn = job.pool.getSharedFunctionReference(fn, '_forTrack');
+        }
+    }
+}
+
+function phaseTrackFnOptimization(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind !== OpKind.RepeaterCreate) {
+                continue;
+            }
+            if (op.track instanceof ReadVarExpr && op.track.name === '$index') {
+                // Top-level access of `$index` uses the built in `repeaterTrackByIndex`.
+                op.trackByFn = importExpr(Identifiers.repeaterTrackByIndex);
+            }
+            else if (op.track instanceof ReadVarExpr && op.track.name === '$item') {
+                // Top-level access of the item uses the built in `repeaterTrackByIdentity`.
+                op.trackByFn = importExpr(Identifiers.repeaterTrackByIdentity);
+            }
+            else if (isTrackByFunctionCall(job.root.xref, op.track)) {
+                // Top-level method calls in the form of `fn($index, item)` can be passed in directly.
+                if (op.track.receiver.receiver.view === unit.xref) {
+                    // TODO: this may be wrong
+                    op.trackByFn = op.track.receiver;
+                }
+                else {
+                    // This is a plain method call, but not in the component's root view.
+                    // We need to get the component instance, and then call the method on it.
+                    op.trackByFn =
+                        importExpr(Identifiers.componentInstance).callFn([]).prop(op.track.receiver.name);
+                    // Because the context is not avaiable (without a special function), we don't want to
+                    // try to resolve it later. Let's get rid of it by overwriting the original track
+                    // expression (which won't be used anyway).
+                    op.track = op.trackByFn;
+                }
+            }
+            else {
+                // The track function could not be optimized.
+                // Replace context reads with a special IR expression, since context reads in a track
+                // function are emitted specially.
+                op.track = transformExpressionsInExpression(op.track, expr => {
+                    if (expr instanceof ContextExpr) {
+                        op.usesComponentInstance = true;
+                        return new TrackContextExpr(expr.view);
+                    }
+                    return expr;
+                }, VisitorContextFlag.None);
+            }
+        }
+    }
+}
+function isTrackByFunctionCall(rootView, expr) {
+    if (!(expr instanceof InvokeFunctionExpr) || expr.args.length !== 2) {
+        return false;
+    }
+    if (!(expr.receiver instanceof ReadPropExpr &&
+        expr.receiver.receiver instanceof ContextExpr) ||
+        expr.receiver.receiver.view !== rootView) {
+        return false;
+    }
+    const [arg0, arg1] = expr.args;
+    if (!(arg0 instanceof ReadVarExpr) || arg0.name !== '$index') {
+        return false;
+    }
+    if (!(arg1 instanceof ReadVarExpr) || arg1.name !== '$item') {
+        return false;
+    }
+    return true;
+}
+
+/**
+ *
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
 const phases = [
     { kind: CompilationJobKind.Tmpl, fn: phaseRemoveContentSelectors },
     { kind: CompilationJobKind.Host, fn: phaseHostStylePropertyParsing },
@@ -21992,6 +22446,8 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: phaseAttributeExtraction },
     { kind: CompilationJobKind.Both, fn: phaseParseExtractedStyles },
     { kind: CompilationJobKind.Tmpl, fn: phaseRemoveEmptyBindings },
+    { kind: CompilationJobKind.Both, fn: phaseCollapseSingletonInterpolations },
+    { kind: CompilationJobKind.Both, fn: phaseOrdering },
     { kind: CompilationJobKind.Tmpl, fn: phaseConditionals },
     { kind: CompilationJobKind.Tmpl, fn: phasePipeCreation },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nTextExtraction },
@@ -22004,7 +22460,10 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: phaseSaveRestoreView },
     { kind: CompilationJobKind.Tmpl, fn: phaseFindAnyCasts },
     { kind: CompilationJobKind.Both, fn: phaseResolveDollarEvent },
+    { kind: CompilationJobKind.Tmpl, fn: phaseRepeaterDerivedVars },
+    { kind: CompilationJobKind.Tmpl, fn: phaseTrackVariables },
     { kind: CompilationJobKind.Both, fn: phaseResolveNames },
+    { kind: CompilationJobKind.Tmpl, fn: phaseTrackFnOptimization },
     { kind: CompilationJobKind.Both, fn: phaseResolveContexts },
     { kind: CompilationJobKind.Tmpl, fn: phaseResolveSanitizers },
     { kind: CompilationJobKind.Tmpl, fn: phaseLocalRefs },
@@ -22013,6 +22472,7 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: phaseTemporaryVariables },
     { kind: CompilationJobKind.Tmpl, fn: phaseSlotAllocation },
     { kind: CompilationJobKind.Tmpl, fn: phaseResolveI18nPlaceholders },
+    { kind: CompilationJobKind.Tmpl, fn: phaseTrackFnGeneration },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nMessageExtraction },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nConstCollection },
     { kind: CompilationJobKind.Tmpl, fn: phaseConstTraitCollection },
@@ -22027,8 +22487,6 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: phaseEmptyElements },
     { kind: CompilationJobKind.Tmpl, fn: phaseNonbindable },
     { kind: CompilationJobKind.Both, fn: phasePureFunctionExtraction },
-    { kind: CompilationJobKind.Tmpl, fn: phaseAlignPipeVariadicVarOffset },
-    { kind: CompilationJobKind.Both, fn: phaseOrdering },
     { kind: CompilationJobKind.Both, fn: phaseReify },
     { kind: CompilationJobKind.Both, fn: phaseChaining },
 ];
@@ -22233,6 +22691,9 @@ function ingestNodes(unit, template) {
         else if (node instanceof Icu$1) {
             ingestIcu(unit, node);
         }
+        else if (node instanceof ForLoopBlock) {
+            ingestForBlock(unit, node);
+        }
         else {
             throw new Error(`Unsupported template node: ${node.constructor.name}`);
         }
@@ -22287,7 +22748,7 @@ function ingestTemplate(unit, tmpl) {
     ingestReferences(tplOp, tmpl);
     ingestNodes(childView, tmpl.children);
     for (const { name, value } of tmpl.variables) {
-        childView.contextVariables.set(name, value);
+        childView.contextVariables.set(name, value !== '' ? value : '$implicit');
     }
     // If this is a plain template and there is an i18n message associated with it, insert i18n start
     // and end ops. For structural directive templates, the i18n ops will be added when ingesting the
@@ -22302,7 +22763,7 @@ function ingestTemplate(unit, tmpl) {
  * Ingest a literal text node from the AST into the given `ViewCompilation`.
  */
 function ingestContent(unit, content) {
-    const op = createProjectionOp(unit.job.allocateXrefId(), content.selector);
+    const op = createProjectionOp(unit.job.allocateXrefId(), content.selector, content.sourceSpan);
     for (const attr of content.attributes) {
         ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, BindingFlags.TextValue);
     }
@@ -22438,6 +22899,50 @@ function ingestIcu(unit, icu) {
         throw Error(`Unhandled i18n metadata type for ICU: ${icu.i18n?.constructor.name}`);
     }
 }
+/**
+ * Ingest an `@for` block into the given `ViewCompilation`.
+ */
+function ingestForBlock(unit, forBlock) {
+    const repeaterView = unit.job.allocateView(unit.xref);
+    const createRepeaterAlias = (ident, repeaterVar) => {
+        repeaterView.aliases.add({
+            kind: SemanticVariableKind.Alias,
+            name: null,
+            identifier: ident,
+            expression: new DerivedRepeaterVarExpr(repeaterView.xref, repeaterVar),
+        });
+    };
+    // Set all the context variables and aliases available in the repeater.
+    repeaterView.contextVariables.set(forBlock.item.name, forBlock.item.value);
+    repeaterView.contextVariables.set(forBlock.contextVariables.$index.name, forBlock.contextVariables.$index.value);
+    repeaterView.contextVariables.set(forBlock.contextVariables.$count.name, forBlock.contextVariables.$count.value);
+    createRepeaterAlias(forBlock.contextVariables.$first.name, DerivedRepeaterVarIdentity.First);
+    createRepeaterAlias(forBlock.contextVariables.$last.name, DerivedRepeaterVarIdentity.Last);
+    createRepeaterAlias(forBlock.contextVariables.$even.name, DerivedRepeaterVarIdentity.Even);
+    createRepeaterAlias(forBlock.contextVariables.$odd.name, DerivedRepeaterVarIdentity.Odd);
+    const sourceSpan = convertSourceSpan(forBlock.trackBy.span, forBlock.sourceSpan);
+    const track = convertAst(forBlock.trackBy, unit.job, sourceSpan);
+    ingestNodes(repeaterView, forBlock.children);
+    let emptyView = null;
+    if (forBlock.empty !== null) {
+        emptyView = unit.job.allocateView(unit.xref);
+        ingestNodes(emptyView, forBlock.empty.children);
+    }
+    const varNames = {
+        $index: forBlock.contextVariables.$index.name,
+        $count: forBlock.contextVariables.$count.name,
+        $first: forBlock.contextVariables.$first.name,
+        $last: forBlock.contextVariables.$last.name,
+        $even: forBlock.contextVariables.$even.name,
+        $odd: forBlock.contextVariables.$odd.name,
+        $implicit: forBlock.item.name,
+    };
+    const repeaterCreate = createRepeaterCreateOp(repeaterView.xref, emptyView?.xref ?? null, track, varNames, forBlock.sourceSpan);
+    unit.create.push(repeaterCreate);
+    const expression = convertAst(forBlock.expression, unit.job, convertSourceSpan(forBlock.expression.span, forBlock.sourceSpan));
+    const repeater = createRepeaterOp(repeaterCreate.xref, expression, forBlock.sourceSpan);
+    unit.update.push(repeater);
+}
 /**
  * Convert a template AST expression into an output AST expression.
  */
@@ -22490,7 +22995,8 @@ function convertAst(ast, job, baseSourceSpan) {
     else if (ast instanceof LiteralMap) {
         const entries = ast.keys.map((key, idx) => {
             const value = ast.values[idx];
-            // TODO: should literals have source maps, or do we just map the whole surrounding expression?
+            // TODO: should literals have source maps, or do we just map the whole surrounding
+            // expression?
             return new LiteralMapEntry(key.key, convertAst(value, job, baseSourceSpan), key.quoted);
         });
         return new LiteralMapExpr(entries, undefined, convertSourceSpan(ast.span, baseSourceSpan));
@@ -23323,7 +23829,7 @@ class WhitespaceVisitor {
         return expansionCase;
     }
     visitBlock(block, context) {
-        return new Block(block.name, block.parameters, visitAllWithSiblings(this, block.children), block.sourceSpan, block.startSourceSpan, block.endSourceSpan);
+        return new Block(block.name, block.parameters, visitAllWithSiblings(this, block.children), block.sourceSpan, block.nameSpan, block.startSourceSpan, block.endSourceSpan);
     }
     visitBlockParameter(parameter, context) {
         return parameter;
@@ -23962,7 +24468,7 @@ function createSwitchBlock(ast, visitor, bindingParser) {
             continue;
         }
         if ((node.name !== 'case' || node.parameters.length === 0) && node.name !== 'default') {
-            unknownBlocks.push(new UnknownBlock(node.name, node.sourceSpan));
+            unknownBlocks.push(new UnknownBlock(node.name, node.sourceSpan, node.nameSpan));
             continue;
         }
         const expression = node.name === 'case' ?
@@ -24940,7 +25446,7 @@ class HtmlAstToIvyAst {
                     errorMessage = `Unrecognized block @${block.name}.`;
                 }
                 result = {
-                    node: new UnknownBlock(block.name, block.sourceSpan),
+                    node: new UnknownBlock(block.name, block.sourceSpan, block.nameSpan),
                     errors: [new ParseError(block.sourceSpan, errorMessage)],
                 };
                 break;
@@ -29756,7 +30262,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.0.0-rc.0');
+const VERSION = new Version('17.0.0-rc.1');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -31286,7 +31792,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-rc.0'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -31394,7 +31900,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-rc.0'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -31671,7 +32177,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-rc.0'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -31706,7 +32212,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-rc.0'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -31757,7 +32263,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-rc.0'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -31790,7 +32296,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-rc.0'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     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.
@@ -31841,7 +32347,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-rc.0'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);