@angular-eslint/bundled-angular-compiler 17.0.0-alpha.0 → 17.0.0

package/dist/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * @license Angular v17.0.0-rc.2
+ * @license Angular v17.0.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8745,62 +8745,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.
@@ -9285,12 +9293,12 @@ function createAdvanceOp(delta, sourceSpan) {
 /**
  * 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,
@@ -9303,11 +9311,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,
     };
@@ -10042,6 +10050,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:
@@ -10052,9 +10071,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:
@@ -10507,17 +10526,17 @@ function createExtractedAttributeOp(target, bindingKind, name, expression) {
 /**
  * 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,
     };
 }
@@ -10533,6 +10552,7 @@ function createI18nStartOp(xref, message, root) {
         message,
         messageIndex: null,
         subTemplateIndex: null,
+        context: null,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -10547,6 +10567,18 @@ function createI18nEndOp(xref) {
         ...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 createHostPropertyOp(name, expression, isAnimationTrigger, sourceSpan) {
     return {
@@ -10599,10 +10631,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();
@@ -10781,7 +10814,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);
             }
         }
     }
@@ -10794,8 +10827,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;
@@ -10806,21 +10839,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);
             }
         }
     }
@@ -11362,6 +11407,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.
@@ -11424,6 +11596,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;
@@ -11721,26 +11913,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.
  */
@@ -18975,35 +19210,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) {
@@ -19013,6 +19236,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.
  *
@@ -19084,36 +19341,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.
  */
@@ -19121,22 +19360,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;
@@ -19147,17 +19386,18 @@ 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));
+                        // 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));
                     }
-                    if (ops.length > 0) ;
                     OpList.replaceWithMany(op, ops);
                     break;
             }
@@ -19165,53 +19405,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.
@@ -19246,6 +19439,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.
  */
@@ -19876,7 +20120,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);
@@ -19923,59 +20169,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()) {
@@ -20105,13 +20298,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);
 }
@@ -20185,7 +20386,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),
@@ -20265,6 +20466,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) {
@@ -20665,8 +20869,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());
@@ -20705,7 +20912,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 = [];
@@ -20823,7 +21030,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));
@@ -20867,6 +21074,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;
@@ -20977,6 +21187,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
@@ -21091,14 +21320,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);
@@ -21107,16 +21336,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;
@@ -21135,7 +21364,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:
@@ -21149,7 +21378,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;
@@ -21160,9 +21389,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;
             }
@@ -21192,47 +21421,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);
             }
         }
     }
@@ -22324,6 +22543,7 @@ function wrapI18nIcus(job) {
     { 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 },
@@ -22333,7 +22553,7 @@ function wrapI18nIcus(job) {
     { 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 },
@@ -22354,16 +22574,17 @@ function wrapI18nIcus(job) {
     { 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 },
@@ -26224,7 +26445,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, []);
         }
@@ -29461,7 +29684,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');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = exports.ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -30991,7 +31214,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'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -31099,7 +31322,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'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -31373,7 +31596,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'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -31408,7 +31631,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'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -31459,7 +31682,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'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -31492,7 +31715,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'));
     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.
@@ -31543,7 +31766,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'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/bundled-angular-compiler",
-  "version": "17.0.0-alpha.0",
+  "version": "17.0.0",
   "description": "A CJS bundled version of @angular/compiler",
   "license": "MIT",
   "main": "dist/index.js",
@@ -15,5 +15,5 @@
     "package.json",
     "README.md"
   ],
-  "gitHead": "e0478be1ae5b9010ad1d74eac4d06511250bf13f"
+  "gitHead": "7121d78c95eefc01c306503b22cc9c7526c50633"
 }