@angular/compiler 17.0.0-rc.2 → 17.0.0-rc.3

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-rc.2
+ * @license Angular v17.0.0-rc.3
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8797,62 +8797,70 @@ var OpKind;
      * An operation that controls when a `@defer` loads.
      */
     OpKind[OpKind["DeferOn"] = 27] = "DeferOn";
+    /**
+     * An operation that controls when a `@defer` loads, using a custom expression as the condition.
+     */
+    OpKind[OpKind["DeferWhen"] = 28] = "DeferWhen";
     /**
      * An i18n message that has been extracted for inclusion in the consts array.
      */
-    OpKind[OpKind["ExtractedMessage"] = 28] = "ExtractedMessage";
+    OpKind[OpKind["I18nMessage"] = 29] = "I18nMessage";
     /**
      * A host binding property.
      */
-    OpKind[OpKind["HostProperty"] = 29] = "HostProperty";
+    OpKind[OpKind["HostProperty"] = 30] = "HostProperty";
     /**
      * A namespace change, which causes the subsequent elements to be processed as either HTML or SVG.
      */
-    OpKind[OpKind["Namespace"] = 30] = "Namespace";
+    OpKind[OpKind["Namespace"] = 31] = "Namespace";
     /**
      * Configure a content projeciton definition for the view.
      */
-    OpKind[OpKind["ProjectionDef"] = 31] = "ProjectionDef";
+    OpKind[OpKind["ProjectionDef"] = 32] = "ProjectionDef";
     /**
      * Create a content projection slot.
      */
-    OpKind[OpKind["Projection"] = 32] = "Projection";
+    OpKind[OpKind["Projection"] = 33] = "Projection";
     /**
      * Create a repeater creation instruction op.
      */
-    OpKind[OpKind["RepeaterCreate"] = 33] = "RepeaterCreate";
+    OpKind[OpKind["RepeaterCreate"] = 34] = "RepeaterCreate";
     /**
      * An update up for a repeater.
      */
-    OpKind[OpKind["Repeater"] = 34] = "Repeater";
+    OpKind[OpKind["Repeater"] = 35] = "Repeater";
     /**
      * The start of an i18n block.
      */
-    OpKind[OpKind["I18nStart"] = 35] = "I18nStart";
+    OpKind[OpKind["I18nStart"] = 36] = "I18nStart";
     /**
      * A self-closing i18n on a single element.
      */
-    OpKind[OpKind["I18n"] = 36] = "I18n";
+    OpKind[OpKind["I18n"] = 37] = "I18n";
     /**
      * The end of an i18n block.
      */
-    OpKind[OpKind["I18nEnd"] = 37] = "I18nEnd";
+    OpKind[OpKind["I18nEnd"] = 38] = "I18nEnd";
     /**
      * An expression in an i18n message.
      */
-    OpKind[OpKind["I18nExpression"] = 38] = "I18nExpression";
+    OpKind[OpKind["I18nExpression"] = 39] = "I18nExpression";
     /**
      * An instruction that applies a set of i18n expressions.
      */
-    OpKind[OpKind["I18nApply"] = 39] = "I18nApply";
+    OpKind[OpKind["I18nApply"] = 40] = "I18nApply";
     /**
      * An instruction to create an ICU expression.
      */
-    OpKind[OpKind["Icu"] = 40] = "Icu";
+    OpKind[OpKind["Icu"] = 41] = "Icu";
     /**
      * An instruction to update an ICU expression.
      */
-    OpKind[OpKind["IcuUpdate"] = 41] = "IcuUpdate";
+    OpKind[OpKind["IcuUpdate"] = 42] = "IcuUpdate";
+    /**
+     * An i18n context containing information needed to generate an i18n message.
+     */
+    OpKind[OpKind["I18nContext"] = 43] = "I18nContext";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -9404,15 +9412,26 @@ function createRepeaterOp(repeaterCreate, targetSlot, collection, sourceSpan) {
         ...NEW_OP,
     };
 }
+function createDeferWhenOp(target, expr, prefetch, sourceSpan) {
+    return {
+        kind: OpKind.DeferWhen,
+        target,
+        expr,
+        prefetch,
+        sourceSpan,
+        ...NEW_OP,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+    };
+}
 /**
  * Create an i18n expression op.
  */
-function createI18nExpressionOp(owner, ownerSlot, expression, i18nPlaceholder, resolutionTime, sourceSpan) {
+function createI18nExpressionOp(context, target, handle, expression, i18nPlaceholder, resolutionTime, sourceSpan) {
     return {
         kind: OpKind.I18nExpression,
-        owner,
-        ownerSlot,
-        target: owner,
+        context,
+        target,
+        handle,
         expression,
         i18nPlaceholder,
         resolutionTime,
@@ -9425,11 +9444,11 @@ function createI18nExpressionOp(owner, ownerSlot, expression, i18nPlaceholder, r
 /**
  *Creates an op to apply i18n expression ops
  */
-function createI18nApplyOp(target, targetSlot, sourceSpan) {
+function createI18nApplyOp(target, handle, sourceSpan) {
     return {
         kind: OpKind.I18nApply,
         target,
-        targetSlot,
+        handle,
         sourceSpan,
         ...NEW_OP,
     };
@@ -10209,6 +10228,17 @@ function transformExpressionsInOp(op, transform, flags) {
                     transformExpressionsInExpression(op.placeholderConfig, transform, flags);
             }
             break;
+        case OpKind.I18nMessage:
+            for (const [placeholder, expr] of op.params) {
+                op.params.set(placeholder, transformExpressionsInExpression(expr, transform, flags));
+            }
+            for (const [placeholder, expr] of op.postprocessingParams) {
+                op.postprocessingParams.set(placeholder, transformExpressionsInExpression(expr, transform, flags));
+            }
+            break;
+        case OpKind.DeferWhen:
+            op.expr = transformExpressionsInExpression(op.expr, transform, flags);
+            break;
         case OpKind.Advance:
         case OpKind.Container:
         case OpKind.ContainerEnd:
@@ -10219,9 +10249,9 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.ElementEnd:
         case OpKind.ElementStart:
         case OpKind.EnableBindings:
-        case OpKind.ExtractedMessage:
         case OpKind.I18n:
         case OpKind.I18nApply:
+        case OpKind.I18nContext:
         case OpKind.I18nEnd:
         case OpKind.I18nStart:
         case OpKind.Icu:
@@ -10797,7 +10827,7 @@ function createExtractedAttributeOp(target, bindingKind, name, expression) {
         ...NEW_OP,
     };
 }
-function createDeferOp(xref, main, mainSlot, sourceSpan) {
+function createDeferOp(xref, main, mainSlot, metadata, sourceSpan) {
     return {
         kind: OpKind.Defer,
         xref,
@@ -10815,6 +10845,8 @@ function createDeferOp(xref, main, mainSlot, sourceSpan) {
         placeholderMinimumTime: null,
         errorView: null,
         errorSlot: null,
+        metadata,
+        resolverFn: null,
         sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
@@ -10834,17 +10866,17 @@ function createDeferOnOp(defer, trigger, prefetch, sourceSpan) {
 /**
  * Create an `ExtractedMessageOp`.
  */
-function createExtractedMessageOp(owner, message, isRoot) {
+function createI18nMessageOp(xref, i18nBlock, message, messagePlaceholder, params, postprocessingParams, needsPostprocessing) {
     return {
-        kind: OpKind.ExtractedMessage,
-        owner,
+        kind: OpKind.I18nMessage,
+        xref,
+        i18nBlock,
         message,
-        isRoot,
-        params: new Map(),
-        postprocessingParams: new Map(),
-        needsPostprocessing: false,
-        formattedParams: null,
-        formattedPostprocessingParams: null,
+        messagePlaceholder,
+        params,
+        postprocessingParams,
+        needsPostprocessing,
+        subMessages: [],
         ...NEW_OP,
     };
 }
@@ -10860,6 +10892,7 @@ function createI18nStartOp(xref, message, root) {
         message,
         messageIndex: null,
         subTemplateIndex: null,
+        context: null,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -10877,15 +10910,30 @@ function createI18nEndOp(xref) {
 /**
  * Creates an op to create an ICU expression.
  */
-function createIcuOp(xref, message, sourceSpan) {
+function createIcuOp(xref, message, icu, messagePlaceholder, sourceSpan) {
     return {
         kind: OpKind.Icu,
         xref,
         message,
+        icu,
+        messagePlaceholder,
+        context: null,
         sourceSpan,
         ...NEW_OP,
     };
 }
+function createI18nContextOp(xref, i18nBlock, message, sourceSpan) {
+    return {
+        kind: OpKind.I18nContext,
+        xref,
+        i18nBlock,
+        message,
+        sourceSpan,
+        params: new Map(),
+        postprocessingParams: new Map(),
+        ...NEW_OP,
+    };
+}
 function literalOrArrayLiteral$1(value) {
     if (Array.isArray(value)) {
         return literalArr(value.map(literalOrArrayLiteral$1));
@@ -10944,10 +10992,11 @@ class CompilationJob {
  * embedded views or host bindings.
  */
 class ComponentCompilationJob extends CompilationJob {
-    constructor(componentName, pool, compatibility, relativeContextFilePath, i18nUseExternalIds) {
+    constructor(componentName, pool, compatibility, relativeContextFilePath, i18nUseExternalIds, deferBlocksMeta) {
         super(componentName, pool, compatibility);
         this.relativeContextFilePath = relativeContextFilePath;
         this.i18nUseExternalIds = i18nUseExternalIds;
+        this.deferBlocksMeta = deferBlocksMeta;
         this.kind = CompilationJobKind.Tmpl;
         this.fnSuffix = 'Template';
         this.views = new Map();
@@ -11126,7 +11175,7 @@ function applyI18nExpressions(job) {
             // Only add apply after expressions that are not followed by more expressions.
             if (op.kind === OpKind.I18nExpression && needsApplication(op)) {
                 // TODO: what should be the source span for the apply op?
-                OpList.insertAfter(createI18nApplyOp(op.owner, op.ownerSlot, null), op);
+                OpList.insertAfter(createI18nApplyOp(op.target, op.handle, null), op);
             }
         }
     }
@@ -11139,8 +11188,8 @@ function needsApplication(op) {
     if (op.next?.kind !== OpKind.I18nExpression) {
         return true;
     }
-    // If the next op is an expression targeting a different i18n block, we need to apply.
-    if (op.next.owner !== op.owner) {
+    // If the next op is an expression targeting a different i18n context, we need to apply.
+    if (op.next.context !== op.context) {
         return true;
     }
     return false;
@@ -11151,21 +11200,33 @@ function needsApplication(op) {
  */
 function assignI18nSlotDependencies(job) {
     const i18nLastSlotConsumers = new Map();
+    const i18nContexts = new Map();
     let lastSlotConsumer = null;
+    let currentI18nOp = null;
     for (const unit of job.units) {
         // Record the last consumed slot before each i18n end instruction.
         for (const op of unit.create) {
-            if (op.kind === OpKind.I18nEnd) {
-                i18nLastSlotConsumers.set(op.xref, lastSlotConsumer);
-            }
             if (hasConsumesSlotTrait(op)) {
                 lastSlotConsumer = op.xref;
             }
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    currentI18nOp = op;
+                    break;
+                case OpKind.I18nEnd:
+                    i18nLastSlotConsumers.set(currentI18nOp.xref, lastSlotConsumer);
+                    currentI18nOp = null;
+                    break;
+                case OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
+                    break;
+            }
         }
         // Assign i18n expressions to target the last slot in its owning block.
         for (const op of unit.update) {
             if (op.kind === OpKind.I18nExpression) {
-                op.target = i18nLastSlotConsumers.get(op.owner);
+                const i18nContext = i18nContexts.get(op.context);
+                op.target = i18nLastSlotConsumers.get(i18nContext.i18nBlock);
             }
         }
     }
@@ -11729,6 +11790,133 @@ function serializeAttributes({ attributes, bindings, classes, i18n, projectAs, s
     return literalArr(attrArray);
 }
 
+/**
+ * Create extracted deps functions for defer ops.
+ */
+function createDeferDepsFns(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.Defer) {
+                if (op.metadata.deps.length === 0) {
+                    continue;
+                }
+                const dependencies = [];
+                for (const dep of op.metadata.deps) {
+                    if (dep.isDeferrable) {
+                        // Callback function, e.g. `m () => m.MyCmp;`.
+                        const innerFn = arrowFn([new FnParam('m', DYNAMIC_TYPE)], variable('m').prop(dep.symbolName));
+                        // Dynamic import, e.g. `import('./a').then(...)`.
+                        const importExpr = (new DynamicImportExpr(dep.importPath)).prop('then').callFn([innerFn]);
+                        dependencies.push(importExpr);
+                    }
+                    else {
+                        // Non-deferrable symbol, just use a reference to the type.
+                        dependencies.push(dep.type);
+                    }
+                }
+                const depsFnExpr = arrowFn([], literalArr(dependencies));
+                if (op.handle.slot === null) {
+                    throw new Error('AssertionError: slot must be assigned bfore extracting defer deps functions');
+                }
+                op.resolverFn = job.pool.getSharedFunctionReference(depsFnExpr, `${job.componentName}_Defer_${op.handle.slot}_DepsFn`);
+            }
+        }
+    }
+}
+
+/**
+ * Create one helper context op per i18n block (including generate descending blocks).
+ *
+ * Also, if an ICU exists inside an i18n block that also contains other localizable content (such as
+ * string), create an additional helper context op for the ICU.
+ *
+ * These context ops are later used for generating i18n messages. (Although we generate at least one
+ * context op per nested view, we will collect them up the tree later, to generate a top-level
+ * message.)
+ */
+function createI18nContexts(job) {
+    let currentI18nOp = null;
+    let xref;
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    // Each i18n block gets its own context.
+                    xref = job.allocateXrefId();
+                    unit.create.push(createI18nContextOp(xref, op.xref, op.message, null));
+                    op.context = xref;
+                    currentI18nOp = op;
+                    break;
+                case OpKind.I18nEnd:
+                    currentI18nOp = null;
+                    break;
+                case OpKind.Icu:
+                    // If an ICU represents a different message than its containing block, we give it its own
+                    // i18n context.
+                    if (currentI18nOp === null) {
+                        throw Error('Unexpected ICU outside of an i18n block.');
+                    }
+                    if (op.message.id !== currentI18nOp.message.id) {
+                        // There was an enclosing i18n block around this ICU somewhere.
+                        xref = job.allocateXrefId();
+                        unit.create.push(createI18nContextOp(xref, currentI18nOp.xref, op.message, null));
+                        op.context = xref;
+                    }
+                    else {
+                        // The i18n block was generated because of this ICU, OR it was explicit, but the ICU is
+                        // the only localizable content inside of it.
+                        op.context = currentI18nOp.context;
+                    }
+                    break;
+            }
+        }
+    }
+}
+
+/**
+ * Replace the ICU update ops with i18n expression ops.
+ */
+function createI18nIcuExpressions(job) {
+    const icus = new Map();
+    const i18nContexts = new Map();
+    const i18nBlocks = new Map();
+    // Collect maps of ops that need to be referenced to create the I18nExpressionOps.
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.Icu:
+                    icus.set(op.xref, op);
+                    break;
+                case OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
+                    break;
+                case OpKind.I18nStart:
+                    i18nBlocks.set(op.xref, op);
+                    break;
+            }
+        }
+        // Replace each IcuUpdateOp with an I18nExpressionOp.
+        for (const op of unit.update) {
+            switch (op.kind) {
+                case OpKind.IcuUpdate:
+                    const icuOp = icus.get(op.xref);
+                    if (icuOp?.icu.expressionPlaceholder === undefined) {
+                        throw Error('ICU should have an i18n placeholder');
+                    }
+                    if (icuOp.context === null) {
+                        throw Error('ICU should have its i18n context set');
+                    }
+                    const i18nContext = i18nContexts.get(icuOp.context);
+                    const i18nBlock = i18nBlocks.get(i18nContext.i18nBlock);
+                    OpList.replace(op, createI18nExpressionOp(i18nContext.xref, i18nBlock.xref, i18nBlock.handle, new LexicalReadExpr(icuOp.icu.expression), icuOp.icu.expressionPlaceholder, 
+                    // ICU-based i18n Expressions are resolved during post-processing.
+                    I18nParamResolutionTime.Postproccessing, null));
+                    break;
+            }
+        }
+    }
+}
+
 /**
  * Defer instructions take a configuration array, which should be collected into the component
  * consts. This phase finds the config options, and creates the corresponding const array.
@@ -11791,6 +11979,26 @@ function resolveDeferTargetNames(job) {
             case DeferTriggerKind.Interaction:
             case DeferTriggerKind.Viewport:
                 if (op.trigger.targetName === null) {
+                    // A `null` target name indicates we should default to the first element in the
+                    // placeholder block.
+                    if (placeholderView === null) {
+                        throw new Error('defer on trigger with no target name must have a placeholder block');
+                    }
+                    const placeholder = job.views.get(placeholderView);
+                    if (placeholder == undefined) {
+                        throw new Error('AssertionError: could not find placeholder view for defer on trigger');
+                    }
+                    for (const placeholderOp of placeholder.create) {
+                        if (hasConsumesSlotTrait(placeholderOp) &&
+                            (isElementOrContainerOp(placeholderOp) ||
+                                placeholderOp.kind === OpKind.Projection)) {
+                            op.trigger.targetXref = placeholderOp.xref;
+                            op.trigger.targetView = placeholderView;
+                            op.trigger.targetSlotViewSteps = -1;
+                            op.trigger.targetSlot = placeholderOp.handle;
+                            return;
+                        }
+                    }
                     return;
                 }
                 let view = placeholderView !== null ? job.views.get(placeholderView) : deferOwnerView;
@@ -12088,26 +12296,69 @@ const LIST_DELIMITER = '|';
  * Formats the param maps on extracted message ops into a maps of `Expression` objects that can be
  * used in the final output.
  */
-function formatI18nParams(job) {
+function extractI18nMessages(job) {
+    // Save the i18n context ops for later use.
+    const i18nContexts = new Map();
+    // Record which contexts represent i18n blocks (any other contexts are assumed to have been
+    // created from ICUs).
+    const i18nBlockContexts = new Set();
     for (const unit of job.units) {
         for (const op of unit.create) {
-            if (op.kind === OpKind.ExtractedMessage) {
-                if (op.isRoot) {
-                    op.formattedParams = formatParams(op.params);
-                    op.formattedPostprocessingParams = formatParams(op.postprocessingParams);
-                    // The message will need post-processing if there are any post-processing params, or if
-                    // there are any normal params that have multiple values
-                    op.needsPostprocessing = op.postprocessingParams.size > 0;
-                    for (const [param, values] of op.params) {
-                        if (values.length > 1) {
-                            op.needsPostprocessing = true;
-                        }
-                    }
+            switch (op.kind) {
+                case OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
+                    break;
+                case OpKind.I18nStart:
+                    i18nBlockContexts.add(op.context);
+                    break;
+            }
+        }
+    }
+    // Extract messages from root i18n blocks.
+    const i18nBlockMessages = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.I18nStart && op.xref === op.root) {
+                if (!op.context) {
+                    throw Error('I18n start op should have its context set.');
                 }
+                const i18nMessageOp = createI18nMessage(job, i18nContexts.get(op.context));
+                i18nBlockMessages.set(op.xref, i18nMessageOp);
+                unit.create.push(i18nMessageOp);
+            }
+        }
+    }
+    // Extract messages from ICUs with their own sub-context.
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.Icu) {
+                if (!op.context) {
+                    throw Error('ICU op should have its context set.');
+                }
+                if (!i18nBlockContexts.has(op.context)) {
+                    const i18nContext = i18nContexts.get(op.context);
+                    const subMessage = createI18nMessage(job, i18nContext, op.messagePlaceholder);
+                    unit.create.push(subMessage);
+                    const parentMessage = i18nBlockMessages.get(i18nContext.i18nBlock);
+                    parentMessage?.subMessages.push(subMessage.xref);
+                }
+                OpList.remove(op);
             }
         }
     }
 }
+/**
+ * Create an i18n message op from an i18n context op.
+ */
+function createI18nMessage(job, context, messagePlaceholder) {
+    let needsPostprocessing = context.postprocessingParams.size > 0;
+    for (const values of context.params.values()) {
+        if (values.length > 1) {
+            needsPostprocessing = true;
+        }
+    }
+    return createI18nMessageOp(job.allocateXrefId(), context.i18nBlock, context.message, messagePlaceholder ?? null, formatParams(context.params), formatParams(context.postprocessingParams), needsPostprocessing);
+}
 /**
  * Formats a map of `I18nParamValue[]` values into a map of `Expression` values.
  */
@@ -19348,35 +19599,23 @@ const TRANSLATION_VAR_PREFIX = 'i18n_';
 function collectI18nConsts(job) {
     const fileBasedI18nSuffix = job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_').toUpperCase() + '_';
     const messageConstIndices = new Map();
+    // Remove all of the i18n message ops into a map.
+    const messages = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
-            if (op.kind === OpKind.ExtractedMessage) {
-                // Serialize the extracted root messages into the const array.
-                if (op.isRoot) {
-                    assertAllParamsResolved(op);
-                    const mainVar = variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));
-                    // Closure Compiler requires const names to start with `MSG_` but disallows any other
-                    // const to start with `MSG_`. We define a variable starting with `MSG_` just for the
-                    // `goog.getMsg` call
-                    const closureVar = i18nGenerateClosureVar(job.pool, op.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
-                    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.formattedPostprocessingParams.size > 0) {
-                            extraTransformFnParams.push(literalMap([...op.formattedPostprocessingParams].map(([key, value]) => ({ key, value, quoted: true }))));
-                        }
-                        transformFn = (expr) => importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
-                    }
-                    const statements = getTranslationDeclStmts$1(op.message, mainVar, closureVar, op.formattedParams, transformFn);
-                    messageConstIndices.set(op.owner, job.addConst(mainVar, statements));
-                }
-                // Remove the extracted messages from the IR now that they have been collected.
+            if (op.kind === OpKind.I18nMessage) {
+                messages.set(op.xref, op);
                 OpList.remove(op);
             }
         }
     }
+    // Serialize the extracted messages for root i18n blocks into the const array.
+    for (const op of messages.values()) {
+        if (op.kind === OpKind.I18nMessage && op.messagePlaceholder === null) {
+            const { mainVar, statements } = collectMessage(job, fileBasedI18nSuffix, messages, op);
+            messageConstIndices.set(op.i18nBlock, job.addConst(mainVar, statements));
+        }
+    }
     // Assign const index to i18n ops that messages were extracted from.
     for (const unit of job.units) {
         for (const op of unit.create) {
@@ -19386,6 +19625,40 @@ function collectI18nConsts(job) {
         }
     }
 }
+/**
+ * Collects the given message into a set of statements that can be added to the const array.
+ * This will recursively collect any sub-messages referenced from the parent message as well.
+ */
+function collectMessage(job, fileBasedI18nSuffix, messages, messageOp) {
+    // Recursively collect any sub-messages, and fill in their placeholders in this message.
+    const statements = [];
+    for (const subMessageId of messageOp.subMessages) {
+        const subMessage = messages.get(subMessageId);
+        const { mainVar: subMessageVar, statements: subMessageStatements } = collectMessage(job, fileBasedI18nSuffix, messages, subMessage);
+        statements.push(...subMessageStatements);
+        messageOp.params.set(subMessage.messagePlaceholder, subMessageVar);
+    }
+    // Check that the message has all of its parameters filled out.
+    assertAllParamsResolved(messageOp);
+    const mainVar = variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX));
+    // Closure Compiler requires const names to start with `MSG_` but disallows any other
+    // const to start with `MSG_`. We define a variable starting with `MSG_` just for the
+    // `goog.getMsg` call
+    const closureVar = i18nGenerateClosureVar(job.pool, messageOp.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
+    let transformFn = undefined;
+    // If nescessary, add a post-processing step and resolve any placeholder params that are
+    // set in post-processing.
+    if (messageOp.needsPostprocessing) {
+        const extraTransformFnParams = [];
+        if (messageOp.postprocessingParams.size > 0) {
+            extraTransformFnParams.push(literalMap([...messageOp.postprocessingParams].map(([key, value]) => ({ key, value, quoted: true }))));
+        }
+        transformFn = (expr) => importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
+    }
+    // Add the message's statements
+    statements.push(...getTranslationDeclStmts$1(messageOp.message, mainVar, closureVar, messageOp.params, transformFn));
+    return { mainVar, statements };
+}
 /**
  * Generate statements that define a given translation message.
  *
@@ -19457,36 +19730,18 @@ function i18nGenerateClosureVar(pool, messageId, fileBasedI18nSuffix, useExterna
  * Asserts that all of the message's placeholders have values.
  */
 function assertAllParamsResolved(op) {
-    if (op.formattedParams === null || op.formattedPostprocessingParams === null) {
-        throw Error('Params should have been formatted.');
-    }
     for (const placeholder in op.message.placeholders) {
-        if (!op.formattedParams.has(placeholder) &&
-            !op.formattedPostprocessingParams.has(placeholder)) {
+        if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
             throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
         }
     }
     for (const placeholder in op.message.placeholderToMessage) {
-        if (!op.formattedParams.has(placeholder) &&
-            !op.formattedPostprocessingParams.has(placeholder)) {
+        if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
             throw Error(`Failed to resolve i18n message placeholder: ${placeholder}`);
         }
     }
 }
 
-/**
- * Extracts i18n messages into their own op.
- */
-function extractI18nMessages(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart) {
-                unit.create.push(createExtractedMessageOp(op.xref, op.message, op.xref === op.root));
-            }
-        }
-    }
-}
-
 /**
  * Removes text nodes within i18n blocks since they are already hardcoded into the i18n message.
  */
@@ -19494,22 +19749,22 @@ function extractI18nText(job) {
     for (const unit of job.units) {
         // Remove all text nodes within i18n blocks, their content is already captured in the i18n
         // message.
-        let currentI18nId = null;
-        let currentI18nSlot = null;
-        const textNodes = new Map();
+        let currentI18n = null;
+        const textNodeI18nBlocks = new Map();
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
-                    currentI18nId = op.xref;
-                    currentI18nSlot = op.handle;
+                    if (op.context === null) {
+                        throw Error('I18n op should have its context set.');
+                    }
+                    currentI18n = op;
                     break;
                 case OpKind.I18nEnd:
-                    currentI18nId = null;
-                    currentI18nSlot = null;
+                    currentI18n = null;
                     break;
                 case OpKind.Text:
-                    if (currentI18nId !== null && currentI18nSlot !== null) {
-                        textNodes.set(op.xref, { xref: currentI18nId, slot: currentI18nSlot });
+                    if (currentI18n !== null) {
+                        textNodeI18nBlocks.set(op.xref, currentI18n);
                         OpList.remove(op);
                     }
                     break;
@@ -19520,18 +19775,17 @@ function extractI18nText(job) {
         for (const op of unit.update) {
             switch (op.kind) {
                 case OpKind.InterpolateText:
-                    if (!textNodes.has(op.target)) {
+                    if (!textNodeI18nBlocks.has(op.target)) {
                         continue;
                     }
-                    const i18nBlock = textNodes.get(op.target);
+                    const i18nOp = textNodeI18nBlocks.get(op.target);
                     const ops = [];
                     for (let i = 0; i < op.interpolation.expressions.length; i++) {
                         const expr = op.interpolation.expressions[i];
                         const placeholder = op.i18nPlaceholders[i];
-                        ops.push(createI18nExpressionOp(i18nBlock.xref, i18nBlock.slot, expr, placeholder.name, I18nParamResolutionTime.Creation, expr.sourceSpan ?? op.sourceSpan));
-                    }
-                    if (ops.length > 0) {
-                        // ops.push(ir.createI18nApplyOp(i18nBlockId, op.i18nPlaceholders, op.sourceSpan));
+                        // For now, this i18nExpression depends on the slot context of the enclosing i18n block.
+                        // Later, we will modify this, and advance to a different point.
+                        ops.push(createI18nExpressionOp(i18nOp.context, i18nOp.xref, i18nOp.handle, expr, placeholder.name, I18nParamResolutionTime.Creation, expr.sourceSpan ?? op.sourceSpan));
                     }
                     OpList.replaceWithMany(op, ops);
                     break;
@@ -19540,53 +19794,6 @@ function extractI18nText(job) {
     }
 }
 
-/**
- * Extracts ICUs into i18n expressions.
- */
-function extractI18nICUs(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;
-        let currentI18nSlot = null;
-        for (const op of unit.create) {
-            switch (op.kind) {
-                case OpKind.I18nStart:
-                    currentI18nId = op.xref;
-                    currentI18nSlot = op.handle;
-                    break;
-                case OpKind.I18nEnd:
-                    currentI18nId = null;
-                    currentI18nSlot = 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, i18nBlockSlot: currentI18nSlot });
-                    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, i18nBlockSlot } = 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, i18nBlockSlot, 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.
@@ -19621,6 +19828,57 @@ function serializeLocalRefs(refs) {
     return literalArr(constRefs);
 }
 
+/**
+ * Merge i18n contexts for child i18n blocks into their ancestor root contexts.
+ */
+function mergeI18nContexts(job) {
+    // Record all of the i18n and extracted message ops for use later.
+    const i18nOps = new Map();
+    const i18nContexts = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    if (!op.context) {
+                        throw Error('I18n op should have its context set.');
+                    }
+                    i18nOps.set(op.xref, op);
+                    break;
+                case OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
+                    break;
+            }
+        }
+    }
+    // For each non-root i18n op, merge its context into the root i18n op's context.
+    for (const childI18nOp of i18nOps.values()) {
+        if (childI18nOp.xref !== childI18nOp.root) {
+            const childContext = i18nContexts.get(childI18nOp.context);
+            const rootI18nOp = i18nOps.get(childI18nOp.root);
+            const rootContext = i18nContexts.get(rootI18nOp.context);
+            mergeParams(rootContext.params, childContext.params);
+            mergeParams(rootContext.postprocessingParams, childContext.postprocessingParams);
+        }
+    }
+}
+/**
+ * Merges the params in the `from` map to into the `to` map.
+ */
+function mergeParams(to, from) {
+    for (const [placeholder, fromValues] of from) {
+        const toValues = to.get(placeholder) || [];
+        // TODO(mmalerba): Child element close tag params should be prepended to maintain the same order
+        // as TemplateDefinitionBuilder. Can be cleaned up when compatibility is no longer required.
+        const flags = fromValues[0].flags;
+        if ((flags & I18nParamValueFlags.CloseTag) && !(flags & I18nParamValueFlags.OpenTag)) {
+            to.set(placeholder, [...fromValues, ...toValues]);
+        }
+        else {
+            to.set(placeholder, [...toValues, ...fromValues]);
+        }
+    }
+}
+
 /**
  * Change namespaces between HTML, SVG and MathML, depending on the next element.
  */
@@ -20251,7 +20509,9 @@ function createVariadicPipes(job) {
 
 /**
  * Propagate i18n blocks down through child templates that act as placeholders in the root i18n
- * message.
+ * message. Specifically, perform an in-order traversal of all the views, and add i18nStart/i18nEnd
+ * op pairs into descending views. Also, assign an increasing sub-template index to each
+ * descending view.
  */
 function propagateI18nBlocks(job) {
     propagateI18nBlocksToTemplates(job.root, 0);
@@ -20298,59 +20558,6 @@ function wrapTemplateWithI18n(unit, parentI18n) {
     }
 }
 
-/**
- * Propagate extractd message placeholders up to their root extracted message op.
- */
-function propogateI18nPlaceholders(job) {
-    // Record all of the i18n and extracted message ops for use later.
-    const i18nOps = new Map();
-    const extractedMessageOps = new Map();
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            switch (op.kind) {
-                case OpKind.I18nStart:
-                    i18nOps.set(op.xref, op);
-                    break;
-                case OpKind.ExtractedMessage:
-                    extractedMessageOps.set(op.owner, op);
-                    break;
-            }
-        }
-    }
-    // For each non-root message, merge its params into the root message's params.
-    for (const [xref, childExtractedMessageOp] of extractedMessageOps) {
-        if (!childExtractedMessageOp.isRoot) {
-            const i18nOp = i18nOps.get(xref);
-            if (i18nOp === undefined) {
-                throw Error('Could not find owner i18n block for extracted message.');
-            }
-            const rootExtractedMessageOp = extractedMessageOps.get(i18nOp.root);
-            if (rootExtractedMessageOp === undefined) {
-                throw Error('Could not find extracted message op for root i18n block.');
-            }
-            mergeParams(rootExtractedMessageOp.params, childExtractedMessageOp.params);
-            mergeParams(rootExtractedMessageOp.postprocessingParams, childExtractedMessageOp.postprocessingParams);
-        }
-    }
-}
-/**
- * Merges the params in the `from` map to into the `to` map.
- */
-function mergeParams(to, from) {
-    for (const [placeholder, fromValues] of from) {
-        const toValues = to.get(placeholder) || [];
-        // TODO(mmalerba): Child element close tag params should be prepended to maintain the same order
-        // as TemplateDefinitionBuilder. Can be cleaned up when compatibility is no longer required.
-        const flags = fromValues[0].flags;
-        if ((flags & I18nParamValueFlags.CloseTag) && !(flags & I18nParamValueFlags.OpenTag)) {
-            to.set(placeholder, [...fromValues, ...toValues]);
-        }
-        else {
-            to.set(placeholder, [...toValues, ...fromValues]);
-        }
-    }
-}
-
 function extractPureFunctions(job) {
     for (const view of job.units) {
         for (const op of view.ops()) {
@@ -20480,13 +20687,21 @@ function elementContainer(slot, constIndex, localRefIndex, sourceSpan) {
 function elementContainerEnd() {
     return call(Identifiers.elementContainerEnd, [], null);
 }
-function template(slot, templateFnRef, decls, vars, tag, constIndex, sourceSpan) {
-    const args = [literal(slot), templateFnRef, literal(decls), literal(vars)];
-    if (tag !== null || constIndex !== null) {
-        args.push(literal(tag));
-        if (constIndex !== null) {
-            args.push(literal(constIndex));
-        }
+function template(slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan) {
+    const args = [
+        literal(slot),
+        templateFnRef,
+        literal(decls),
+        literal(vars),
+        literal(tag),
+        literal(constIndex),
+    ];
+    if (localRefs !== null) {
+        args.push(literal(localRefs));
+        args.push(importExpr(Identifiers.templateRefExtractor));
+    }
+    while (args[args.length - 1].isEquivalent(NULL_EXPR)) {
+        args.pop();
     }
     return call(Identifiers.templateCreate, args, sourceSpan);
 }
@@ -20560,7 +20775,7 @@ function defer(selfSlot, primarySlot, dependencyResolverFn, loadingSlot, placeho
     const args = [
         literal(selfSlot),
         literal(primarySlot),
-        literal(dependencyResolverFn),
+        dependencyResolverFn ?? literal(null),
         literal(loadingSlot),
         literal(placeholderSlot),
         literal(errorSlot),
@@ -20640,6 +20855,9 @@ function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByF
 function repeater(metadataSlot, collection, sourceSpan) {
     return call(Identifiers.repeater, [literal(metadataSlot), collection], sourceSpan);
 }
+function deferWhen(prefetch, expr, sourceSpan) {
+    return call(prefetch ? Identifiers.deferPrefetchWhen : Identifiers.deferWhen, [expr], sourceSpan);
+}
 function i18n(slot, constIndex, subTemplateIndex) {
     const args = [literal(slot), literal(constIndex)];
     if (subTemplateIndex) {
@@ -21040,8 +21258,11 @@ function reifyCreateOperations(unit, ops) {
                 if (!(unit instanceof ViewCompilationUnit)) {
                     throw new Error(`AssertionError: must be compiling a component`);
                 }
+                if (Array.isArray(op.localRefs)) {
+                    throw new Error(`AssertionError: local refs array should have been extracted into a constant`);
+                }
                 const childView = unit.job.views.get(op.xref);
-                OpList.replace(op, template(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.sourceSpan));
+                OpList.replace(op, template(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.localRefs, op.sourceSpan));
                 break;
             case OpKind.DisableBindings:
                 OpList.replace(op, disableBindings());
@@ -21080,7 +21301,7 @@ function reifyCreateOperations(unit, ops) {
                 break;
             case OpKind.Defer:
                 const timerScheduling = !!op.loadingMinimumTime || !!op.loadingAfterTime || !!op.placeholderMinimumTime;
-                OpList.replace(op, defer(op.handle.slot, op.mainSlot.slot, null, op.loadingSlot?.slot ?? null, op.placeholderSlot?.slot ?? null, op.errorSlot?.slot ?? null, op.loadingConfig, op.placeholderConfig, timerScheduling, op.sourceSpan));
+                OpList.replace(op, defer(op.handle.slot, op.mainSlot.slot, op.resolverFn, op.loadingSlot?.slot ?? null, op.placeholderSlot?.slot ?? null, op.errorSlot?.slot ?? null, op.loadingConfig, op.placeholderConfig, timerScheduling, op.sourceSpan));
                 break;
             case OpKind.DeferOn:
                 let args = [];
@@ -21198,7 +21419,7 @@ function reifyUpdateOperations(_unit, ops) {
                 OpList.replace(op, i18nExp(op.expression, op.sourceSpan));
                 break;
             case OpKind.I18nApply:
-                OpList.replace(op, i18nApply(op.targetSlot.slot, op.sourceSpan));
+                OpList.replace(op, i18nApply(op.handle.slot, op.sourceSpan));
                 break;
             case OpKind.InterpolateText:
                 OpList.replace(op, textInterpolate(op.interpolation.strings, op.interpolation.expressions, op.sourceSpan));
@@ -21242,6 +21463,9 @@ function reifyUpdateOperations(_unit, ops) {
             case OpKind.Repeater:
                 OpList.replace(op, repeater(op.targetSlot.slot, op.collection, op.sourceSpan));
                 break;
+            case OpKind.DeferWhen:
+                OpList.replace(op, deferWhen(op.prefetch, op.expr, op.sourceSpan));
+                break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
                 break;
@@ -21352,6 +21576,25 @@ function removeEmptyBindings(job) {
     }
 }
 
+/**
+ * Remove the i18n context ops after they are no longer needed, and null out references to them to
+ * be safe.
+ */
+function removeI18nContexts(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nContext:
+                    OpList.remove(op);
+                    break;
+                case OpKind.I18nStart:
+                    op.context = null;
+                    break;
+            }
+        }
+    }
+}
+
 /**
  * Inside the body of a repeater, certain context variables (such as `$first`) are ambiently
  * available. This phase finds those variable usages, and replaces them with the appropriate
@@ -21466,14 +21709,14 @@ function transformDollarEvent(unit, ops) {
  * Resolve the element placeholders in i18n messages.
  */
 function resolveI18nElementPlaceholders(job) {
-    // Record all of the element and extracted message ops for use later.
-    const extractedMessageOps = new Map();
+    // Record all of the element and i18n context ops for use later.
+    const i18nContexts = new Map();
     const elements = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
-                case OpKind.ExtractedMessage:
-                    extractedMessageOps.set(op.owner, op);
+                case OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
                     break;
                 case OpKind.ElementStart:
                     elements.set(op.xref, op);
@@ -21482,16 +21725,16 @@ function resolveI18nElementPlaceholders(job) {
         }
     }
     for (const unit of job.units) {
-        // Track the current i18n op and corresponding extracted message op as we step through the
-        // creation IR.
+        // Track the current i18n op and corresponding i18n context op as we step through the creation
+        // IR.
         let currentOps = null;
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
-                    if (!extractedMessageOps.has(op.xref)) {
-                        throw Error('Could not find extracted message for i18n op');
+                    if (!op.context) {
+                        throw Error('Could not find i18n context for i18n op');
                     }
-                    currentOps = { i18n: op, extractedMessage: extractedMessageOps.get(op.xref) };
+                    currentOps = { i18nBlock: op, i18nContext: i18nContexts.get(op.context) };
                     break;
                 case OpKind.I18nEnd:
                     currentOps = null;
@@ -21510,7 +21753,7 @@ function resolveI18nElementPlaceholders(job) {
                         if (closeName === '') {
                             flags |= I18nParamValueFlags.CloseTag;
                         }
-                        addParam(currentOps.extractedMessage.params, startName, op.handle.slot, currentOps.i18n.subTemplateIndex, flags);
+                        addParam(currentOps.i18nContext.params, startName, op.handle.slot, currentOps.i18nBlock.subTemplateIndex, flags);
                     }
                     break;
                 case OpKind.ElementEnd:
@@ -21524,7 +21767,7 @@ function resolveI18nElementPlaceholders(job) {
                         const { closeName } = startOp.i18nPlaceholder;
                         // Self-closing tags don't have a closing tag placeholder.
                         if (closeName !== '') {
-                            addParam(currentOps.extractedMessage.params, closeName, startOp.handle.slot, currentOps.i18n.subTemplateIndex, I18nParamValueFlags.ElementTag | I18nParamValueFlags.CloseTag);
+                            addParam(currentOps.i18nContext.params, closeName, startOp.handle.slot, currentOps.i18nBlock.subTemplateIndex, I18nParamValueFlags.ElementTag | I18nParamValueFlags.CloseTag);
                         }
                     }
                     break;
@@ -21535,9 +21778,9 @@ function resolveI18nElementPlaceholders(job) {
                         if (currentOps === null) {
                             throw Error('i18n tag placeholder should only occur inside an i18n block');
                         }
-                        const subTemplateIndex = getSubTemplateIndexForTemplateTag(job, currentOps.i18n, op);
-                        addParam(currentOps.extractedMessage.params, op.i18nPlaceholder.startName, op.handle.slot, subTemplateIndex, I18nParamValueFlags.TemplateTag);
-                        addParam(currentOps.extractedMessage.params, op.i18nPlaceholder.closeName, op.handle.slot, subTemplateIndex, I18nParamValueFlags.TemplateTag | I18nParamValueFlags.CloseTag);
+                        const subTemplateIndex = getSubTemplateIndexForTemplateTag(job, currentOps.i18nBlock, op);
+                        addParam(currentOps.i18nContext.params, op.i18nPlaceholder.startName, op.handle.slot, subTemplateIndex, I18nParamValueFlags.TemplateTag);
+                        addParam(currentOps.i18nContext.params, op.i18nPlaceholder.closeName, op.handle.slot, subTemplateIndex, I18nParamValueFlags.TemplateTag | I18nParamValueFlags.CloseTag);
                     }
                     break;
             }
@@ -21567,47 +21810,37 @@ function addParam(params, placeholder, value, subTemplateIndex, flags = I18nPara
  * Resolve the i18n expression placeholders in i18n messages.
  */
 function resolveI18nExpressionPlaceholders(job) {
-    // Record all of the i18n and extracted message ops for use later.
-    const i18nOps = new Map();
-    const extractedMessageOps = new Map();
+    // Record all of the i18n context ops, and the sub-template index for each i18n op.
+    const subTemplateIndicies = new Map();
+    const i18nContexts = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
-                    i18nOps.set(op.xref, op);
+                    subTemplateIndicies.set(op.xref, op.subTemplateIndex);
                     break;
-                case OpKind.ExtractedMessage:
-                    extractedMessageOps.set(op.owner, op);
+                case OpKind.I18nContext:
+                    i18nContexts.set(op.xref, op);
                     break;
             }
         }
     }
-    // Keep track of the next available expression index per i18n block.
+    // Keep track of the next available expression index per i18n context.
     const expressionIndices = new Map();
     for (const unit of job.units) {
         for (const op of unit.update) {
             if (op.kind === OpKind.I18nExpression) {
-                const i18nOp = i18nOps.get(op.owner);
-                let index = expressionIndices.get(op.owner) || 0;
-                if (!i18nOp) {
-                    throw Error('Cannot find corresponding i18n block for i18nExpr');
-                }
-                const extractedMessageOp = extractedMessageOps.get(i18nOp.xref);
-                if (!extractedMessageOp) {
-                    throw Error('Cannot find extracted message for i18n block');
-                }
+                const index = expressionIndices.get(op.context) || 0;
+                const i18nContext = i18nContexts.get(op.context);
+                const subTemplateIndex = subTemplateIndicies.get(i18nContext.i18nBlock);
                 // Add the expression index in the appropriate params map.
                 const params = op.resolutionTime === I18nParamResolutionTime.Creation ?
-                    extractedMessageOp.params :
-                    extractedMessageOp.postprocessingParams;
+                    i18nContext.params :
+                    i18nContext.postprocessingParams;
                 const values = params.get(op.i18nPlaceholder) || [];
-                values.push({
-                    value: index,
-                    subTemplateIndex: i18nOp.subTemplateIndex,
-                    flags: I18nParamValueFlags.None
-                });
+                values.push({ value: index, subTemplateIndex: subTemplateIndex, flags: I18nParamValueFlags.None });
                 params.set(op.i18nPlaceholder, values);
-                expressionIndices.set(op.owner, index + 1);
+                expressionIndices.set(op.context, index + 1);
             }
         }
     }
@@ -22699,6 +22932,7 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: specializeBindings },
     { kind: CompilationJobKind.Tmpl, fn: propagateI18nBlocks },
     { kind: CompilationJobKind.Tmpl, fn: wrapI18nIcus },
+    { kind: CompilationJobKind.Tmpl, fn: createI18nContexts },
     { kind: CompilationJobKind.Both, fn: extractAttributes },
     { kind: CompilationJobKind.Both, fn: parseExtractedStyles },
     { kind: CompilationJobKind.Tmpl, fn: removeEmptyBindings },
@@ -22708,7 +22942,7 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: createPipes },
     { kind: CompilationJobKind.Tmpl, fn: configureDeferInstructions },
     { kind: CompilationJobKind.Tmpl, fn: extractI18nText },
-    { kind: CompilationJobKind.Tmpl, fn: extractI18nICUs },
+    { kind: CompilationJobKind.Tmpl, fn: createI18nIcuExpressions },
     { kind: CompilationJobKind.Tmpl, fn: applyI18nExpressions },
     { kind: CompilationJobKind.Tmpl, fn: createVariadicPipes },
     { kind: CompilationJobKind.Both, fn: generatePureLiteralStructures },
@@ -22729,16 +22963,17 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: expandSafeReads },
     { kind: CompilationJobKind.Both, fn: generateTemporaryVariables },
     { kind: CompilationJobKind.Tmpl, fn: allocateSlots },
-    { kind: CompilationJobKind.Tmpl, fn: extractI18nMessages },
+    { kind: CompilationJobKind.Tmpl, fn: createDeferDepsFns },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nElementPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nExpressionPlaceholders },
-    { kind: CompilationJobKind.Tmpl, fn: propogateI18nPlaceholders },
-    { kind: CompilationJobKind.Tmpl, fn: formatI18nParams },
+    { kind: CompilationJobKind.Tmpl, fn: mergeI18nContexts },
+    { kind: CompilationJobKind.Tmpl, fn: extractI18nMessages },
     { kind: CompilationJobKind.Tmpl, fn: generateTrackFns },
     { kind: CompilationJobKind.Tmpl, fn: collectI18nConsts },
     { kind: CompilationJobKind.Tmpl, fn: collectConstExpressions },
     { kind: CompilationJobKind.Both, fn: collectElementConsts },
     { kind: CompilationJobKind.Tmpl, fn: assignI18nSlotDependencies },
+    { kind: CompilationJobKind.Tmpl, fn: removeI18nContexts },
     { kind: CompilationJobKind.Both, fn: countVariables },
     { kind: CompilationJobKind.Tmpl, fn: generateAdvance },
     { kind: CompilationJobKind.Both, fn: optimizeVariables },
@@ -22864,8 +23099,8 @@ const compatibilityMode = CompatibilityMode.TemplateDefinitionBuilder;
  * representation.
  * TODO: Refactor more of the ingestion code into phases.
  */
-function ingestComponent(componentName, template, constantPool, relativeContextFilePath, i18nUseExternalIds) {
-    const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, relativeContextFilePath, i18nUseExternalIds);
+function ingestComponent(componentName, template, constantPool, relativeContextFilePath, i18nUseExternalIds, deferBlocksMeta) {
+    const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, relativeContextFilePath, i18nUseExternalIds, deferBlocksMeta);
     ingestNodes(job.root, template);
     return job;
 }
@@ -22975,7 +23210,12 @@ function ingestElement(unit, element) {
     ingestBindings(unit, startOp, element);
     ingestReferences(startOp, element);
     ingestNodes(unit, element.children);
-    const endOp = createElementEndOp(id, element.endSourceSpan);
+    // The source span for the end op is typically the element closing tag. However, if no closing tag
+    // exists, such as in `<input>`, we use the start source span instead. Usually the start and end
+    // instructions will be collapsed into one `element` instruction, negating the purpose of this
+    // fallback, but in cases when it is not collapsed (such as an input with a binding), we still
+    // want to map the end instruction to the main element.
+    const endOp = createElementEndOp(id, element.endSourceSpan ?? element.startSourceSpan);
     unit.create.push(endOp);
     // If there is an i18n message associated with this element, insert i18n start and end ops.
     if (element.i18n instanceof Message) {
@@ -23130,6 +23370,10 @@ function ingestDeferView(unit, suffix, children, sourceSpan) {
     return templateOp;
 }
 function ingestDeferBlock(unit, deferBlock) {
+    const blockMeta = unit.job.deferBlocksMeta.get(deferBlock);
+    if (blockMeta === undefined) {
+        throw new Error(`AssertionError: unable to find metadata for deferred block`);
+    }
     // Generate the defer main view and all secondary views.
     const main = ingestDeferView(unit, '', deferBlock.children, deferBlock.sourceSpan);
     const loading = ingestDeferView(unit, 'Loading', deferBlock.loading?.children, deferBlock.loading?.sourceSpan);
@@ -23137,7 +23381,7 @@ function ingestDeferBlock(unit, deferBlock) {
     const error = ingestDeferView(unit, 'Error', deferBlock.error?.children, deferBlock.error?.sourceSpan);
     // Create the main defer op, and ops for all secondary views.
     const deferXref = unit.job.allocateXrefId();
-    const deferOp = createDeferOp(deferXref, main.xref, main.handle, deferBlock.sourceSpan);
+    const deferOp = createDeferOp(deferXref, main.xref, main.handle, blockMeta, deferBlock.sourceSpan);
     deferOp.placeholderView = placeholder?.xref ?? null;
     deferOp.placeholderSlot = placeholder?.handle ?? null;
     deferOp.loadingSlot = loading?.handle ?? null;
@@ -23151,17 +23395,18 @@ function ingestDeferBlock(unit, deferBlock) {
     // make it easier to refactor prefetch behavior in the future.
     let prefetch = false;
     let deferOnOps = [];
+    let deferWhenOps = [];
     for (const triggers of [deferBlock.triggers, deferBlock.prefetchTriggers]) {
         if (triggers.idle !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Idle }, prefetch, null);
+            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Idle }, prefetch, triggers.idle.sourceSpan);
             deferOnOps.push(deferOnOp);
         }
         if (triggers.immediate !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Immediate }, prefetch, null);
+            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Immediate }, prefetch, triggers.immediate.sourceSpan);
             deferOnOps.push(deferOnOp);
         }
         if (triggers.timer !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Timer, delay: triggers.timer.delay }, prefetch, null);
+            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Timer, delay: triggers.timer.delay }, prefetch, triggers.timer.sourceSpan);
             deferOnOps.push(deferOnOp);
         }
         if (triggers.hover !== undefined) {
@@ -23172,7 +23417,7 @@ function ingestDeferBlock(unit, deferBlock) {
                 targetSlot: null,
                 targetView: null,
                 targetSlotViewSteps: null,
-            }, prefetch, null);
+            }, prefetch, triggers.hover.sourceSpan);
             deferOnOps.push(deferOnOp);
         }
         if (triggers.interaction !== undefined) {
@@ -23183,7 +23428,7 @@ function ingestDeferBlock(unit, deferBlock) {
                 targetSlot: null,
                 targetView: null,
                 targetSlotViewSteps: null,
-            }, prefetch, null);
+            }, prefetch, triggers.interaction.sourceSpan);
             deferOnOps.push(deferOnOp);
         }
         if (triggers.viewport !== undefined) {
@@ -23194,21 +23439,26 @@ function ingestDeferBlock(unit, deferBlock) {
                 targetSlot: null,
                 targetView: null,
                 targetSlotViewSteps: null,
-            }, prefetch, null);
+            }, prefetch, triggers.viewport.sourceSpan);
             deferOnOps.push(deferOnOp);
         }
+        if (triggers.when !== undefined) {
+            const deferOnOp = createDeferWhenOp(deferXref, convertAst(triggers.when.value, unit.job, triggers.when.sourceSpan), prefetch, triggers.when.sourceSpan);
+            deferWhenOps.push(deferOnOp);
+        }
         // If no (non-prefetching) defer triggers were provided, default to `idle`.
-        if (deferOnOps.length === 0) {
+        if (deferOnOps.length === 0 && deferWhenOps.length === 0) {
             deferOnOps.push(createDeferOnOp(deferXref, { kind: DeferTriggerKind.Idle }, false, null));
         }
         prefetch = true;
     }
     unit.create.push(deferOnOps);
+    unit.update.push(deferWhenOps);
 }
 function ingestIcu(unit, icu) {
-    if (icu.i18n instanceof Message) {
+    if (icu.i18n instanceof Message && isSingleI18nIcu(icu.i18n)) {
         const xref = unit.job.allocateXrefId();
-        unit.create.push(createIcuOp(xref, icu.i18n, null));
+        unit.create.push(createIcuOp(xref, icu.i18n, icu.i18n.nodes[0], icuFromI18nMessage(icu.i18n).name, null));
         unit.update.push(createIcuUpdateOp(xref, null));
     }
     else {
@@ -23276,6 +23526,11 @@ function convertAst(ast, job, baseSourceSpan) {
         }
     }
     else if (ast instanceof PropertyWrite) {
+        if (ast.receiver instanceof ImplicitReceiver) {
+            return new WritePropExpr(
+            // TODO: Is it correct to always use the root context in place of the implicit receiver?
+            new ContextExpr(job.root.xref), ast.name, convertAst(ast.value, job, baseSourceSpan), null, convertSourceSpan(ast.span, baseSourceSpan));
+        }
         return new WritePropExpr(convertAst(ast.receiver, job, baseSourceSpan), ast.name, convertAst(ast.value, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
     }
     else if (ast instanceof KeyedWrite) {
@@ -23351,7 +23606,7 @@ function convertAst(ast, job, baseSourceSpan) {
         return new EmptyExpr(convertSourceSpan(ast.span, baseSourceSpan));
     }
     else {
-        throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
+        throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
     }
 }
 /**
@@ -23583,7 +23838,9 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
         for (const attr of root.attributes) {
             ingestBinding(unit, xref, attr.name, literal(attr.value), 1 /* e.BindingType.Attribute */, null, SecurityContext.NONE, attr.sourceSpan, BindingFlags.TextValue);
         }
-        return root instanceof Element$1 ? root.name : root.tagName;
+        const tagName = root instanceof Element$1 ? root.name : root.tagName;
+        // Don't pass along `ng-template` tag name since it enables directive matching.
+        return tagName === 'ng-template' ? null : tagName;
     }
     return null;
 }
@@ -27423,7 +27680,9 @@ class TemplateDefinitionBuilder {
         // that we don't copy any bound attributes since they don't participate in content projection
         // and they can be used in directive matching (in the case of `Template.templateAttrs`).
         if (root !== null) {
-            tagName = root instanceof Element$1 ? root.name : root.tagName;
+            const name = root instanceof Element$1 ? root.name : root.tagName;
+            // Don't pass along `ng-template` tag name since it enables directive matching.
+            tagName = name === NG_TEMPLATE_TAG_NAME ? null : name;
             attrsExprs =
                 this.getAttributeExpressions(NG_TEMPLATE_TAG_NAME, root.attributes, root.inputs, []);
         }
@@ -28689,7 +28948,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     else {
         // This path compiles the template using the prototype template pipeline. First the template is
         // ingested into IR:
-        const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, meta.relativeContextFilePath, meta.i18nUseExternalIds);
+        const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.deferBlocks);
         // Then the IR is transformed to prepare it for cod egeneration.
         transform(tpl, CompilationJobKind.Tmpl);
         // Finally we emit the template function:
@@ -30712,7 +30971,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.0.0-rc.2');
+const VERSION = new Version('17.0.0-rc.3');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -32242,7 +32501,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('17.0.0-rc.2'));
+    definitionMap.set('version', literal('17.0.0-rc.3'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -32350,7 +32609,7 @@ function createDirectiveDefinitionMap(meta) {
     // in 16.1 is actually used.
     const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION$5 : '14.0.0';
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('17.0.0-rc.2'));
+    definitionMap.set('version', literal('17.0.0-rc.3'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -32627,7 +32886,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('17.0.0-rc.2'));
+    definitionMap.set('version', literal('17.0.0-rc.3'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -32662,7 +32921,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('17.0.0-rc.2'));
+    definitionMap.set('version', literal('17.0.0-rc.3'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -32713,7 +32972,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('17.0.0-rc.2'));
+    definitionMap.set('version', literal('17.0.0-rc.3'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -32746,7 +33005,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('17.0.0-rc.2'));
+    definitionMap.set('version', literal('17.0.0-rc.3'));
     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.
@@ -32797,7 +33056,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('17.0.0-rc.2'));
+    definitionMap.set('version', literal('17.0.0-rc.3'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);