@angular/compiler 17.0.0-next.8 → 17.0.0-rc.1

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.8
+ * @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);
@@ -8317,7 +8318,7 @@ class ShadowCss {
             // (ie: ".\fc ber" for ".über") is not a separator between 2 selectors
             // also keep in mind that backslashes are replaced by a placeholder by SafeSelector
             // These escaped selectors happen for example when esbuild runs with optimization.minify.
-            if (part.match(_placeholderRe) && selector[res.index + 1]?.match(/[a-fA-F\d]/)) {
+            if (part.match(/__esc-ph-(\d+)__/) && selector[res.index + 1]?.match(/[a-fA-F\d]/)) {
                 continue;
             }
             shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
@@ -8348,7 +8349,13 @@ class SafeSelector {
         // pseudo-class, but writing `.foo\:blue` will match, because the colon was escaped.
         // Replace all escape sequences (`\` followed by a character) with a placeholder so
         // that our handling of pseudo-selectors doesn't mess with them.
-        selector = this._escapeRegexMatches(selector, /(\\.)/g);
+        // Escaped characters have a specific placeholder so they can be detected separately.
+        selector = selector.replace(/(\\.)/g, (_, keep) => {
+            const replaceBy = `__esc-ph-${this.index}__`;
+            this.placeholders.push(keep);
+            this.index++;
+            return replaceBy;
+        });
         // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
         // WS and "+" would otherwise be interpreted as selector separators.
         this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
@@ -8359,7 +8366,7 @@ class SafeSelector {
         });
     }
     restore(content) {
-        return content.replace(_placeholderRe, (_ph, index) => this.placeholders[+index]);
+        return content.replace(/__(?:ph|esc-ph)-(\d+)__/g, (_ph, index) => this.placeholders[+index]);
     }
     content() {
         return this._content;
@@ -8411,7 +8418,6 @@ const _commentRe = /\/\*[\s\S]*?\*\//g;
 const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=/g;
 const COMMENT_PLACEHOLDER = '%COMMENT%';
 const _commentWithHashPlaceHolderRe = new RegExp(COMMENT_PLACEHOLDER, 'g');
-const _placeholderRe = /__ph-(\d+)__/g;
 const BLOCK_PLACEHOLDER = '%BLOCK%';
 const _ruleRe = new RegExp(`(\\s*(?:${COMMENT_PLACEHOLDER}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`, 'g');
 const CONTENT_PAIRS = new Map([['{', '}']]);
@@ -8821,26 +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"] = 41] = "Icu";
+    /**
+     * An instruction to update an ICU expression.
+     */
+    OpKind[OpKind["IcuUpdate"] = 42] = "IcuUpdate";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -8855,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.
  */
@@ -8953,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
@@ -9019,6 +9064,22 @@ var BindingKind;
      */
     BindingKind[BindingKind["Animation"] = 6] = "Animation";
 })(BindingKind || (BindingKind = {}));
+/**
+ * Enumeration of possible times i18n params can be resolved.
+ */
+var I18nParamResolutionTime;
+(function (I18nParamResolutionTime) {
+    /**
+     * Param is resolved at message creation time. Most params should be resolved at message creation
+     * time. However, ICU params need to be handled in post-processing.
+     */
+    I18nParamResolutionTime[I18nParamResolutionTime["Creation"] = 0] = "Creation";
+    /**
+     * Param is resolved during post-processing. This should be used for params who's value comes from
+     * an ICU.
+     */
+    I18nParamResolutionTime[I18nParamResolutionTime["Postproccessing"] = 1] = "Postproccessing";
+})(I18nParamResolutionTime || (I18nParamResolutionTime = {}));
 
 /**
  * Marker symbol for `ConsumesSlotOpTrait`.
@@ -9132,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,
     };
 }
@@ -9314,16 +9376,27 @@ 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.
  */
-function createI18nExpressionOp(owner, expression, i18nPlaceholder, sourceSpan) {
+function createI18nExpressionOp(owner, expression, i18nPlaceholder, resolutionTime, sourceSpan) {
     return {
         kind: OpKind.I18nExpression,
         owner,
         target: owner,
         expression,
         i18nPlaceholder,
+        resolutionTime,
         sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_VARS,
@@ -9331,7 +9404,7 @@ function createI18nExpressionOp(owner, expression, i18nPlaceholder, sourceSpan)
     };
 }
 /**
- * Creates an op to apply i18n expression ops.
+ *Creates an op to apply i18n expression ops
  */
 function createI18nApplyOp(target, sourceSpan) {
     return {
@@ -9342,6 +9415,17 @@ function createI18nApplyOp(target, sourceSpan) {
         ...TRAIT_USES_SLOT_INDEX,
     };
 }
+/**
+ * Creates an op to update an ICU expression.
+ */
+function createIcuUpdateOp(xref, sourceSpan) {
+    return {
+        kind: OpKind.IcuUpdate,
+        xref,
+        sourceSpan,
+        ...NEW_OP,
+    };
+}
 
 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
 /**
@@ -9368,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;
@@ -9427,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.
  */
@@ -9944,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.
  */
@@ -10038,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) {
@@ -10064,6 +10208,8 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Advance:
         case OpKind.Namespace:
         case OpKind.I18nApply:
+        case OpKind.Icu:
+        case OpKind.IcuUpdate:
             // These operations contain no expressions.
             break;
         default:
@@ -10440,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.
@@ -10487,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`.
  */
@@ -10577,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,
     };
@@ -10662,8 +10829,10 @@ function createI18nStartOp(xref, message, root) {
         root: root ?? xref,
         message,
         params: new Map(),
+        postprocessingParams: new Map(),
         messageIndex: null,
         subTemplateIndex: null,
+        needsPostprocessing: false,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -10678,6 +10847,18 @@ function createI18nEndOp(xref) {
         ...NEW_OP,
     };
 }
+/**
+ * Creates an op to create an ICU expression.
+ */
+function createIcuOp(xref, message, sourceSpan) {
+    return {
+        kind: OpKind.Icu,
+        xref,
+        message,
+        sourceSpan,
+        ...NEW_OP,
+    };
+}
 function literalOrArrayLiteral$1(value) {
     if (Array.isArray(value)) {
         return literalArr(value.map(literalOrArrayLiteral$1));
@@ -10850,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.
@@ -10882,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.
  */
@@ -11088,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;
 }
 
 /**
@@ -11108,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:
@@ -11116,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:
@@ -11126,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:
@@ -11138,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;
@@ -11149,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.');
@@ -11187,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);
@@ -11197,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.');
@@ -11223,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 {
@@ -11383,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 = [];
         }
     }
 }
@@ -11834,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.
@@ -11948,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;
@@ -11974,6 +12087,7 @@ function getScopeForView(view, parent) {
             view: view.xref,
         },
         contextVariables: new Map(),
+        aliases: view.aliases,
         references: [],
         parent,
     };
@@ -11986,7 +12100,6 @@ function getScopeForView(view, parent) {
     }
     for (const op of view.create) {
         switch (op.kind) {
-            case OpKind.Element:
             case OpKind.ElementStart:
             case OpKind.Template:
                 if (!Array.isArray(op.localRefs)) {
@@ -12022,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.
@@ -12154,7 +12271,7 @@ function phaseI18nConstCollection(job) {
     // 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) {
+            if (op.kind === OpKind.I18nStart) {
                 op.messageIndex = messageConstIndices[op.root];
             }
         }
@@ -13916,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;
     }
@@ -14451,7 +14569,7 @@ let TAG_DEFINITIONS;
 function getHtmlTagDefinition(tagName) {
     if (!TAG_DEFINITIONS) {
         DEFAULT_TAG_DEFINITION = new HtmlTagDefinition({ canSelfClose: true });
-        TAG_DEFINITIONS = {
+        TAG_DEFINITIONS = Object.assign(Object.create(null), {
             'base': new HtmlTagDefinition({ isVoid: true }),
             'meta': new HtmlTagDefinition({ isVoid: true }),
             'area': new HtmlTagDefinition({ isVoid: true }),
@@ -14513,9 +14631,9 @@ function getHtmlTagDefinition(tagName) {
                 contentType: { default: TagContentType.ESCAPABLE_RAW_TEXT, svg: TagContentType.PARSABLE_DATA }
             }),
             'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
-        };
+        });
         new DomElementSchemaRegistry().allKnownElementNames().forEach(knownTagName => {
-            if (!TAG_DEFINITIONS.hasOwnProperty(knownTagName) && getNsPrefix(knownTagName) === null) {
+            if (!TAG_DEFINITIONS[knownTagName] && getNsPrefix(knownTagName) === null) {
                 TAG_DEFINITIONS[knownTagName] = new HtmlTagDefinition({ canSelfClose: false });
             }
         });
@@ -17734,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;
@@ -17757,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);
@@ -18474,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) {
@@ -18494,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);
@@ -19053,7 +19160,7 @@ 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.kind === OpKind.I18n)) {
+            if (op.kind === OpKind.I18nStart) {
                 // 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.
@@ -19063,8 +19170,17 @@ function phaseI18nMessageExtraction(job) {
                     // 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*/);
+                    let transformFn = undefined;
+                    // If nescessary, add a post-processing step and resolve any placeholder params that are
+                    // set in post-processing.
+                    if (op.needsPostprocessing) {
+                        const extraTransformFnParams = [];
+                        if (op.postprocessingParams.size > 0) {
+                            extraTransformFnParams.push(literalMap([...op.postprocessingParams.entries()].map(([key, value]) => ({ key, value, quoted: true }))));
+                        }
+                        transformFn = (expr) => importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
+                    }
+                    const statements = getTranslationDeclStmts$1(op.message, mainVar, closureVar, params, transformFn);
                     unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
                 }
             }
@@ -19177,7 +19293,7 @@ function phaseI18nTextExtraction(job) {
                     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));
+                        ops.push(createI18nExpressionOp(i18nBlockId, expr, placeholder.name, I18nParamResolutionTime.Creation, expr.sourceSpan ?? op.sourceSpan));
                     }
                     if (ops.length > 0) {
                         // ops.push(ir.createI18nApplyOp(i18nBlockId, op.i18nPlaceholders, op.sourceSpan));
@@ -19189,6 +19305,50 @@ function phaseI18nTextExtraction(job) {
     }
 }
 
+/**
+ * Extracts ICUs into i18n expressions.
+ */
+function phaseIcuExtraction(job) {
+    for (const unit of job.units) {
+        // Build a map of ICU to the i18n block they belong to, then remove the `Icu` ops.
+        const icus = new Map();
+        let currentI18nId = null;
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    currentI18nId = op.xref;
+                    break;
+                case OpKind.I18nEnd:
+                    currentI18nId = null;
+                    break;
+                case OpKind.Icu:
+                    if (currentI18nId === null) {
+                        throw Error('Unexpected ICU outside of an i18n block.');
+                    }
+                    icus.set(op.xref, { message: op.message, i18nBlockId: currentI18nId });
+                    OpList.remove(op);
+                    break;
+            }
+        }
+        // Replace the `IcuUpdate` ops with `i18nExpr` ops.
+        for (const op of unit.update) {
+            switch (op.kind) {
+                case OpKind.IcuUpdate:
+                    const { message, i18nBlockId } = icus.get(op.xref);
+                    const icuNode = message.nodes.find((n) => n instanceof Icu);
+                    if (icuNode === undefined) {
+                        throw Error('Could not find ICU in i18n AST');
+                    }
+                    if (icuNode.expressionPlaceholder === undefined) {
+                        throw Error('ICU is missing an i18n placeholder');
+                    }
+                    OpList.replace(op, createI18nExpressionOp(i18nBlockId, new LexicalReadExpr(icuNode.expression), icuNode.expressionPlaceholder, I18nParamResolutionTime.Postproccessing, null));
+                    break;
+            }
+        }
+    }
+}
+
 /**
  * Lifts local reference declarations on element-like structures within each view into an entry in
  * the `consts` array for the whole component.
@@ -19198,7 +19358,6 @@ function phaseLocalRefs(job) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.ElementStart:
-                case OpKind.Element:
                 case OpKind.Template:
                     if (!Array.isArray(op.localRefs)) {
                         throw new Error(`AssertionError: expected localRefs to be an array still`);
@@ -19231,7 +19390,7 @@ function phaseNamespace(job) {
     for (const unit of job.units) {
         let activeNamespace = Namespace.HTML;
         for (const op of unit.create) {
-            if (op.kind !== OpKind.Element && op.kind !== OpKind.ElementStart) {
+            if (op.kind !== OpKind.ElementStart) {
                 continue;
             }
             if (op.namespace !== activeNamespace) {
@@ -19368,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`);
@@ -19376,7 +19551,8 @@ function addNamesToView(unit, baseName, state, compatibility) {
                 if (op.slot === null) {
                     throw new Error(`Expected slot to be assigned`);
                 }
-                addNamesToView(childView, `${baseName}_${prefixWithNamespace(op.tag, op.namespace)}_${op.slot}`, state, compatibility);
+                const tagToken = op.tag === null ? '' : '_' + prefixWithNamespace(op.tag, op.namespace);
+                addNamesToView(childView, `${baseName}${tagToken}_${op.slot}`, state, compatibility);
                 break;
             case OpKind.StyleProp:
                 op.name = normalizeStylePropName(op.name);
@@ -19412,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;
         }
     }
@@ -19510,11 +19688,6 @@ 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;
@@ -19531,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.');
@@ -19560,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);
             }
         }
@@ -19588,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 = [
@@ -19598,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.
@@ -19624,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`.
@@ -19708,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;
             }
         }
     }
@@ -19724,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;
 }
@@ -19749,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));
+            }
         });
     }
 }
@@ -19847,37 +20041,6 @@ function wrapTemplateWithI18n(unit, parentI18n) {
     }
 }
 
-function phasePropagateI18nPlaceholders(job) {
-    // Get all of the i18n ops.
-    const i18nOps = new Map();
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart) {
-                i18nOps.set(op.xref, op);
-            }
-        }
-    }
-    // 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);
-            }
-        }
-    }
-    // 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}`);
-                }
-            }
-        }
-    }
-}
-
 function phasePureFunctionExtraction(job) {
     for (const view of job.units) {
         for (const op of view.ops()) {
@@ -19905,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++) {
@@ -20008,7 +20172,7 @@ function elementContainerEnd() {
 }
 function template(slot, templateFnRef, decls, vars, tag, constIndex, sourceSpan) {
     const args = [literal(slot), templateFnRef, literal(decls), literal(vars)];
-    if (tag !== null) {
+    if (tag !== null || constIndex !== null) {
         args.push(literal(tag));
         if (constIndex !== null) {
             args.push(literal(constIndex));
@@ -20104,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)];
@@ -20121,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) {
@@ -20575,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.
@@ -20672,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;
@@ -20810,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) {
@@ -20881,6 +21101,10 @@ const LIST_END_MARKER = ']';
  * Delimiter used to separate multiple values in a list.
  */
 const LIST_DELIMITER = '|';
+/**
+ * Flags that describe what an i18n param value. These determine how the value is serialized into
+ * the final map.
+ */
 var I18nParamValueFlags;
 (function (I18nParamValueFlags) {
     I18nParamValueFlags[I18nParamValueFlags["None"] = 0] = "None";
@@ -20893,10 +21117,13 @@ var I18nParamValueFlags;
      */
     I18nParamValueFlags[I18nParamValueFlags["TemplateTag"] = 2] = "TemplateTag";
     /**
-     * This value represents the closing of a tag. (Can only be used together with ElementTag or
-     * TemplateTag)
+     * This value represents the opening of a tag.
+     */
+    I18nParamValueFlags[I18nParamValueFlags["OpenTag"] = 4] = "OpenTag";
+    /**
+     * This value represents the closing of a tag.
      */
-    I18nParamValueFlags[I18nParamValueFlags["CloseTag"] = 4] = "CloseTag";
+    I18nParamValueFlags[I18nParamValueFlags["CloseTag"] = 8] = "CloseTag";
 })(I18nParamValueFlags || (I18nParamValueFlags = {}));
 /**
  * Represents the complete i18n params map for an i18n op.
@@ -20908,9 +21135,9 @@ class I18nPlaceholderParams {
     /**
      * Adds a new value to the params map.
      */
-    addValue(placeholder, value, subTemplateIndex, flags) {
+    addValue(placeholder, value, subTemplateIndex, resolutionTime, flags) {
         const placeholderValues = this.values.get(placeholder) ?? [];
-        placeholderValues.push({ value, subTemplateIndex, flags });
+        placeholderValues.push({ value, subTemplateIndex, resolutionTime, flags });
         this.values.set(placeholder, placeholderValues);
     }
     /**
@@ -20918,13 +21145,49 @@ class I18nPlaceholderParams {
      */
     saveToOp(op) {
         for (const [placeholder, placeholderValues] of this.values) {
-            op.params.set(placeholder, literal(this.serializeValues(placeholderValues)));
+            // We need to run post-processing for any 1i8n ops that contain parameters with more than
+            // one value, even if there are no parameters resolved at post-processing time.
+            const creationValues = placeholderValues.filter(({ resolutionTime }) => resolutionTime === I18nParamResolutionTime.Creation);
+            if (creationValues.length > 1) {
+                op.needsPostprocessing = true;
+            }
+            // Save creation time params to op.
+            const serializedCreationValues = this.serializeValues(creationValues);
+            if (serializedCreationValues !== null) {
+                op.params.set(placeholder, literal(serializedCreationValues));
+            }
+            // Save post-processing time params to op.
+            const serializedPostprocessingValues = this.serializeValues(placeholderValues.filter(({ resolutionTime }) => resolutionTime === I18nParamResolutionTime.Postproccessing));
+            if (serializedPostprocessingValues !== null) {
+                op.needsPostprocessing = true;
+                op.postprocessingParams.set(placeholder, literal(serializedPostprocessingValues));
+            }
+        }
+    }
+    /**
+     * Merges another param map into this one.
+     */
+    merge(other) {
+        for (const [placeholder, otherValues] of other.values) {
+            const currentValues = this.values.get(placeholder) || [];
+            // Child element close tag params should be prepended to maintain the same order as
+            // TemplateDefinitionBuilder.
+            const flags = otherValues[0].flags;
+            if ((flags & I18nParamValueFlags.CloseTag) && !(flags & I18nParamValueFlags.OpenTag)) {
+                this.values.set(placeholder, [...otherValues, ...currentValues]);
+            }
+            else {
+                this.values.set(placeholder, [...currentValues, ...otherValues]);
+            }
         }
     }
     /**
      * Serializes a list of i18n placeholder values.
      */
     serializeValues(values) {
+        if (values.length === 0) {
+            return null;
+        }
         const serializedValues = values.map(value => this.serializeValue(value));
         return serializedValues.length === 1 ?
             serializedValues[0] :
@@ -20946,6 +21209,11 @@ class I18nPlaceholderParams {
             closeMarker = value.flags & I18nParamValueFlags.CloseTag ? TAG_CLOSE_MARKER : '';
         }
         const context = value.subTemplateIndex === null ? '' : `${CONTEXT_MARKER}${value.subTemplateIndex}`;
+        // Self-closing tags use a special form that concatenates the start and close tag values.
+        if ((value.flags & I18nParamValueFlags.OpenTag) &&
+            (value.flags & I18nParamValueFlags.CloseTag)) {
+            return `${ESCAPE}${tagMarker}${value.value}${context}${ESCAPE}${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+        }
         return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
     }
 }
@@ -20953,36 +21221,81 @@ class I18nPlaceholderParams {
  * Resolve the placeholders in i18n messages.
  */
 function phaseResolveI18nPlaceholders(job) {
+    const params = new Map();
+    const i18nOps = new Map();
+    resolvePlaceholders(job, params, i18nOps);
+    propagatePlaceholders(params, i18nOps);
+    // After colleccting all params, save them to the i18n ops.
+    for (const [xref, i18nOpParams] of params) {
+        i18nOpParams.saveToOp(i18nOps.get(xref));
+    }
+    // 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) && !op.postprocessingParams.has(placeholder)) {
+                    throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Resolve placeholders for each i18n op.
+ */
+function resolvePlaceholders(job, params, i18nOps) {
     for (const unit of job.units) {
-        const i18nOps = new Map();
-        const params = new Map();
+        const elements = new Map();
         let currentI18nOp = null;
         // Record slots for tag name placeholders.
         for (const op of unit.create) {
             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.
+                    // For elements with i18n placeholders, record its slot value in the params map under the
+                    // corresponding tag start placeholder.
                     if (op.i18nPlaceholder !== undefined) {
                         if (currentI18nOp === null) {
                             throw Error('i18n tag placeholder should only occur inside an i18n block');
                         }
+                        elements.set(op.xref, op);
                         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);
+                        let flags = I18nParamValueFlags.ElementTag | I18nParamValueFlags.OpenTag;
+                        // For self-closing tags, there is no close tag placeholder. Instead, the start tag
+                        // placeholder accounts for the start and close of the element.
+                        if (closeName === '') {
+                            flags |= I18nParamValueFlags.CloseTag;
+                        }
+                        addParam(params, currentI18nOp, startName, op.slot, currentI18nOp.subTemplateIndex, I18nParamResolutionTime.Creation, flags);
+                    }
+                    break;
+                case OpKind.ElementEnd:
+                    const startOp = elements.get(op.xref);
+                    if (startOp && startOp.i18nPlaceholder !== undefined) {
+                        if (currentI18nOp === null) {
+                            throw Error('i18n tag placeholder should only occur inside an i18n block');
+                        }
+                        const { closeName } = startOp.i18nPlaceholder;
+                        // Self-closing tags don't have a closing tag placeholder.
+                        if (closeName !== '') {
+                            addParam(params, currentI18nOp, closeName, startOp.slot, currentI18nOp.subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.ElementTag | I18nParamValueFlags.CloseTag);
+                        }
+                    }
+                    break;
+                case OpKind.Template:
+                    if (op.i18nPlaceholder !== undefined) {
+                        if (currentI18nOp === null) {
+                            throw Error('i18n tag placeholder should only occur inside an i18n block');
+                        }
+                        const subTemplateIndex = getSubTemplateIndexForTemplateTag(job, currentI18nOp, op);
+                        addParam(params, currentI18nOp, op.i18nPlaceholder.startName, op.slot, subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.TemplateTag);
+                        addParam(params, currentI18nOp, op.i18nPlaceholder.closeName, op.slot, subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.TemplateTag | I18nParamValueFlags.CloseTag);
                     }
                     break;
             }
@@ -20996,39 +21309,44 @@ function phaseResolveI18nPlaceholders(job) {
                 if (!i18nOp) {
                     throw Error('Cannot find corresponding i18nStart for i18nExpr');
                 }
-                addParam(params, i18nOp, op.i18nPlaceholder.name, index++, i18nOp.subTemplateIndex);
+                addParam(params, i18nOp, op.i18nPlaceholder, index++, i18nOp.subTemplateIndex, op.resolutionTime);
                 i18nBlockPlaceholderIndices.set(op.owner, index);
             }
         }
-        // After colleccting all params, save them to the i18n ops.
-        for (const [xref, i18nOpParams] of params) {
-            i18nOpParams.saveToOp(i18nOps.get(xref));
-        }
     }
 }
 /**
  * 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);
+function addParam(params, i18nOp, placeholder, value, subTemplateIndex, resolutionTime, flags = I18nParamValueFlags.None) {
+    const i18nOpParams = params.get(i18nOp.xref) || new I18nPlaceholderParams();
+    i18nOpParams.addValue(placeholder, value, subTemplateIndex, resolutionTime, 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.
+ * Get the subTemplateIndex for the given template op. For template ops, use the subTemplateIndex of
+ * the child i18n block inside the template.
  */
-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;
-            }
+function getSubTemplateIndexForTemplateTag(job, i18nOp, op) {
+    for (const childOp of job.views.get(op.xref).create) {
+        if (childOp.kind === OpKind.I18nStart) {
+            return childOp.subTemplateIndex;
         }
     }
     return i18nOp.subTemplateIndex;
 }
+/**
+ * Propagate placeholders up to their root i18n op.
+ */
+function propagatePlaceholders(params, i18nOps) {
+    for (const [xref, opParams] of params) {
+        const op = i18nOps.get(xref);
+        if (op.xref !== op.root) {
+            const rootParams = params.get(op.root) || new I18nPlaceholderParams();
+            rootParams.merge(opParams);
+        }
+    }
+}
 
 /**
  * Resolves lexical references in views (`ir.LexicalReadExpr`) to either a target variable or to
@@ -21058,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;
@@ -21140,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) {
@@ -21154,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)) {
@@ -21170,8 +21489,7 @@ function phaseResolveSanitizers(job) {
  * Checks whether the given op represents an iframe element.
  */
 function isIframeElement$1(op) {
-    return (op.kind === OpKind.Element || op.kind === OpKind.ElementStart) &&
-        op.tag.toLowerCase() === 'iframe';
+    return op.kind === OpKind.ElementStart && op.tag?.toLowerCase() === 'iframe';
 }
 
 function phaseSaveRestoreView(job) {
@@ -21181,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) {
@@ -21211,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
@@ -21266,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}`);
@@ -21414,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.
  *
@@ -21434,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) {
@@ -21476,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.
  */
@@ -21545,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;
         }
@@ -21564,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) {
@@ -21785,6 +22274,167 @@ function allowConservativeInlining(decl, target) {
     }
 }
 
+/**
+ * Wraps ICUs that do not already belong to an i18n block in a new i18n block.
+ */
+function phaseWrapIcus(job) {
+    for (const unit of job.units) {
+        let currentI18nOp = null;
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    currentI18nOp = op;
+                    break;
+                case OpKind.I18nEnd:
+                    currentI18nOp = null;
+                    break;
+                case OpKind.Icu:
+                    if (currentI18nOp === null) {
+                        const id = job.allocateXrefId();
+                        OpList.insertBefore(createI18nStartOp(id, op.message), op);
+                        OpList.insertAfter(createI18nEndOp(id), op);
+                    }
+                    break;
+            }
+        }
+    }
+}
+
+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 },
@@ -21792,12 +22442,16 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: phaseStyleBindingSpecialization },
     { kind: CompilationJobKind.Both, fn: phaseBindingSpecialization },
     { kind: CompilationJobKind.Tmpl, fn: phasePropagateI18nBlocks },
+    { kind: CompilationJobKind.Tmpl, fn: phaseWrapIcus },
     { 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 },
+    { kind: CompilationJobKind.Tmpl, fn: phaseIcuExtraction },
     { kind: CompilationJobKind.Tmpl, fn: phaseApplyI18nExpressions },
     { kind: CompilationJobKind.Tmpl, fn: phasePipeVariadic },
     { kind: CompilationJobKind.Both, fn: phasePureLiteralStructures },
@@ -21806,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 },
@@ -21815,7 +22472,7 @@ 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: phaseTrackFnGeneration },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nMessageExtraction },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nConstCollection },
     { kind: CompilationJobKind.Tmpl, fn: phaseConstTraitCollection },
@@ -21830,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 },
 ];
@@ -22033,6 +22688,12 @@ function ingestNodes(unit, template) {
         else if (node instanceof DeferredBlock) {
             ingestDeferBlock(unit, node);
         }
+        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}`);
         }
@@ -22081,17 +22742,18 @@ function ingestTemplate(unit, tmpl) {
         [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, i18nPlaceholder, tmpl.startSourceSpan);
+    const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace, namespaceForKey(namespacePrefix), false, i18nPlaceholder, tmpl.startSourceSpan);
     unit.create.push(tplOp);
     ingestBindings(unit, tplOp, 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 there is an i18n message associated with this template, insert i18n start and end ops.
-    if (tmpl.i18n instanceof Message) {
+    // 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
+    // element/template the directive is placed on.
+    if (isPlainTemplate(tmpl) && 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);
@@ -22101,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);
     }
@@ -22227,6 +22889,60 @@ function ingestDeferBlock(unit, deferBlock) {
     // Add all ops to the view.
     unit.create.push(deferOnOp);
 }
+function ingestIcu(unit, icu) {
+    if (icu.i18n instanceof Message) {
+        const xref = unit.job.allocateXrefId();
+        unit.create.push(createIcuOp(xref, icu.i18n, null));
+        unit.update.push(createIcuUpdateOp(xref, null));
+    }
+    else {
+        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.
  */
@@ -22279,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));
@@ -22320,16 +23037,35 @@ function convertAst(ast, job, baseSourceSpan) {
         throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
     }
 }
+/**
+ * Checks whether the given template is a plain ng-template (as opposed to another kind of template
+ * such as a structural directive template or control flow template). This is checked based on the
+ * tagName. We can expect that only plain ng-templates will come through with a tagName of
+ * 'ng-template'.
+ *
+ * Here are some of the cases we expect:
+ *
+ * | Angular HTML                       | Template tagName   |
+ * | ---------------------------------- | ------------------ |
+ * | `<ng-template>`                    | 'ng-template'      |
+ * | `<div *ngIf="true">`               | 'div'              |
+ * | `<svg><ng-template>`               | 'svg:ng-template'  |
+ * | `@if (true) {`                     | 'Conditional'      |
+ * | `<ng-template *ngIf>` (plain)      | 'ng-template'      |
+ * | `<ng-template *ngIf>` (structural) | null               |
+ */
+function isPlainTemplate(tmpl) {
+    return splitNsName(tmpl.tagName ?? '')[1] === 'ng-template';
+}
 /**
  * Process all of the bindings on an element-like structure in the template AST and convert them
  * 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) {
+        if (element instanceof Template && isPlainTemplate(element)) {
             flags |= BindingFlags.BindingTargetsTemplate;
         }
         const templateAttrFlags = flags | BindingFlags.BindingTargetsTemplate | BindingFlags.IsStructuralTemplateAttribute;
@@ -22358,7 +23094,7 @@ function ingestBindings(unit, op, element) {
                 throw Error('Animation listener should have a phase');
             }
         }
-        if (element instanceof Template && !isPlainTemplate) {
+        if (element instanceof Template && !isPlainTemplate(element)) {
             unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, output.name, null));
             continue;
         }
@@ -23093,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;
@@ -23732,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' ?
@@ -24710,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;
@@ -29526,7 +30262,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.0.0-next.8');
+const VERSION = new Version('17.0.0-rc.1');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -31056,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-next.8'));
+    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);
@@ -31164,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-next.8'));
+    definitionMap.set('version', literal('17.0.0-rc.1'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -31441,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-next.8'));
+    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));
@@ -31476,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-next.8'));
+    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
@@ -31527,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-next.8'));
+    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);
@@ -31560,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-next.8'));
+    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.
@@ -31611,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-next.8'));
+    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);