@angular/compiler 17.0.7 → 17.0.8

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.7
+ * @license Angular v17.0.8
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2308,7 +2308,9 @@ class ConstantPool {
             }))));
         }
     }
-    getSharedFunctionReference(fn, prefix) {
+    // TODO: useUniqueName(false) is necessary for naming compatibility with
+    // TemplateDefinitionBuilder, but should be removed once Template Pipeline is the default.
+    getSharedFunctionReference(fn, prefix, useUniqueName = true) {
         const isArrow = fn instanceof ArrowFunctionExpr;
         for (const current of this.statements) {
             // Arrow functions are saved as variables so we check if the
@@ -2323,7 +2325,7 @@ class ConstantPool {
             }
         }
         // Otherwise declare the function.
-        const name = this.uniqueName(prefix);
+        const name = useUniqueName ? this.uniqueName(prefix) : prefix;
         this.statements.push(fn.toDeclStmt(name, StmtModifier.Final));
         return variable(name);
     }
@@ -3685,13 +3687,18 @@ var TagContentType;
     TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
     TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
 })(TagContentType || (TagContentType = {}));
-function splitNsName(elementName) {
+function splitNsName(elementName, fatal = true) {
     if (elementName[0] != ':') {
         return [null, elementName];
     }
     const colonIndex = elementName.indexOf(':', 1);
     if (colonIndex === -1) {
-        throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+        if (fatal) {
+            throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+        }
+        else {
+            return [null, elementName];
+        }
     }
     return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
 }
@@ -8966,14 +8973,18 @@ var OpKind;
      * An instruction to update an ICU expression.
      */
     OpKind[OpKind["IcuEnd"] = 42] = "IcuEnd";
+    /**
+     * An instruction representing a placeholder in an ICU expression.
+     */
+    OpKind[OpKind["IcuPlaceholder"] = 43] = "IcuPlaceholder";
     /**
      * An i18n context containing information needed to generate an i18n message.
      */
-    OpKind[OpKind["I18nContext"] = 43] = "I18nContext";
+    OpKind[OpKind["I18nContext"] = 44] = "I18nContext";
     /**
      * A creation op that corresponds to i18n attributes on an element.
      */
-    OpKind[OpKind["I18nAttributes"] = 44] = "I18nAttributes";
+    OpKind[OpKind["I18nAttributes"] = 45] = "I18nAttributes";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -9572,12 +9583,13 @@ function createDeferWhenOp(target, expr, prefetch, sourceSpan) {
         sourceSpan,
         ...NEW_OP,
         ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
     };
 }
 /**
  * Create an i18n expression op.
  */
-function createI18nExpressionOp(context, target, i18nOwner, handle, expression, i18nPlaceholder, resolutionTime, usage, name, sourceSpan) {
+function createI18nExpressionOp(context, target, i18nOwner, handle, expression, icuPlaceholder, i18nPlaceholder, resolutionTime, usage, name, sourceSpan) {
     return {
         kind: OpKind.I18nExpression,
         context,
@@ -9585,6 +9597,7 @@ function createI18nExpressionOp(context, target, i18nOwner, handle, expression,
         i18nOwner,
         handle,
         expression,
+        icuPlaceholder,
         i18nPlaceholder,
         resolutionTime,
         usage,
@@ -10354,6 +10367,9 @@ function transformExpressionsInOp(op, transform, flags) {
                 op.placeholderConfig =
                     transformExpressionsInExpression(op.placeholderConfig, transform, flags);
             }
+            if (op.resolverFn !== null) {
+                op.resolverFn = transformExpressionsInExpression(op.resolverFn, transform, flags);
+            }
             break;
         case OpKind.I18nMessage:
             for (const [placeholder, expr] of op.params) {
@@ -10390,6 +10406,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Template:
         case OpKind.Text:
         case OpKind.I18nAttributes:
+        case OpKind.IcuPlaceholder:
             // These operations contain no expressions.
             break;
         default:
@@ -10797,7 +10814,7 @@ function isElementOrContainerOp(op) {
 /**
  * Create an `ElementStartOp`.
  */
-function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan) {
+function createElementStartOp(tag, xref, namespace, i18nPlaceholder, startSourceSpan, wholeSourceSpan) {
     return {
         kind: OpKind.ElementStart,
         xref,
@@ -10808,7 +10825,8 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan)
         nonBindable: false,
         namespace,
         i18nPlaceholder,
-        sourceSpan,
+        startSourceSpan,
+        wholeSourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
     };
@@ -10816,7 +10834,7 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan)
 /**
  * Create a `TemplateOp`.
  */
-function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, sourceSpan) {
+function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, startSourceSpan, wholeSourceSpan) {
     return {
         kind: OpKind.Template,
         xref,
@@ -10831,12 +10849,13 @@ function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace
         nonBindable: false,
         namespace,
         i18nPlaceholder,
-        sourceSpan,
+        startSourceSpan,
+        wholeSourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
     };
 }
-function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, sourceSpan) {
+function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, startSourceSpan, wholeSourceSpan) {
     return {
         kind: OpKind.RepeaterCreate,
         attributes: null,
@@ -10856,9 +10875,11 @@ function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, i1
         usesComponentInstance: false,
         i18nPlaceholder,
         emptyI18nPlaceholder,
-        sourceSpan,
+        startSourceSpan,
+        wholeSourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
+        ...TRAIT_CONSUMES_VARS,
         numSlotsUsed: emptyView === null ? 2 : 3,
     };
 }
@@ -10890,12 +10911,13 @@ function createEnableBindingsOp(xref) {
 /**
  * Create a `TextOp`.
  */
-function createTextOp(xref, initialValue, sourceSpan) {
+function createTextOp(xref, initialValue, icuPlaceholder, sourceSpan) {
     return {
         kind: OpKind.Text,
         xref,
         handle: new SlotHandle(),
         initialValue,
+        icuPlaceholder,
         sourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
@@ -11085,6 +11107,19 @@ function createIcuEndOp(xref) {
         ...NEW_OP,
     };
 }
+/**
+ * Creates an ICU placeholder op.
+ */
+function createIcuPlaceholderOp(xref, name, strings) {
+    return {
+        kind: OpKind.IcuPlaceholder,
+        xref,
+        name,
+        strings,
+        expressionPlaceholders: [],
+        ...NEW_OP,
+    };
+}
 function createI18nContextOp(contextKind, xref, i18nBlock, message, sourceSpan) {
     if (i18nBlock === null && contextKind !== I18nContextKind.Attr) {
         throw new Error('AssertionError: i18nBlock must be provided for non-attribute contexts.');
@@ -11551,21 +11586,11 @@ function extractAttributeOp(unit, op, elements) {
     if (op.expression instanceof Interpolation) {
         return;
     }
-    let extractable = op.expression.isConstant();
+    let extractable = op.isTextAttribute || op.expression.isConstant();
     if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
-        // TemplateDefinitionBuilder only extracted attributes that were string literals.
-        extractable = isStringLiteral(op.expression);
-        if (op.name === 'style' || op.name === 'class') {
-            // For style and class attributes, TemplateDefinitionBuilder only extracted them if they were
-            // text attributes. For example, `[attr.class]="'my-class'"` was not extracted despite being a
-            // string literal, because it is not a text attribute.
-            extractable &&= op.isTextAttribute;
-        }
-        if (unit.job.kind === CompilationJobKind.Host) {
-            // TemplateDefinitionBuilder also does not seem to extract string literals if they are part of
-            // a host attribute.
-            extractable &&= op.isTextAttribute;
-        }
+        // TemplateDefinitionBuilder only extracts text attributes. It does not extract attriibute
+        // bindings, even if they are constants.
+        extractable &&= op.isTextAttribute;
     }
     if (extractable) {
         const extractedAttributeOp = createExtractedAttributeOp(op.target, op.isStructuralTemplateAttribute ? BindingKind.Template : BindingKind.Attribute, op.name, op.expression, op.i18nContext, op.i18nMessage, op.securityContext);
@@ -11859,7 +11884,7 @@ function collectElementConsts(job) {
     for (const unit of job.units) {
         for (const op of unit.create) {
             if (op.kind === OpKind.ExtractedAttribute) {
-                const attributes = allElementAttributes.get(op.target) || new ElementAttributes();
+                const attributes = allElementAttributes.get(op.target) || new ElementAttributes(job.compatibility);
                 allElementAttributes.set(op.target, attributes);
                 attributes.add(op.bindingKind, op.name, op.expression, op.trustedValueFn);
                 OpList.remove(op);
@@ -11904,11 +11929,6 @@ const FLYWEIGHT_ARRAY = Object.freeze([]);
  * Container for all of the various kinds of attributes which are applied on an element.
  */
 class ElementAttributes {
-    constructor() {
-        this.known = new Set();
-        this.byKind = new Map;
-        this.projectAs = null;
-    }
     get attributes() {
         return this.byKind.get(BindingKind.Attribute) ?? FLYWEIGHT_ARRAY;
     }
@@ -11927,11 +11947,31 @@ class ElementAttributes {
     get i18n() {
         return this.byKind.get(BindingKind.I18n) ?? FLYWEIGHT_ARRAY;
     }
+    constructor(compatibility) {
+        this.compatibility = compatibility;
+        this.known = new Map();
+        this.byKind = new Map;
+        this.projectAs = null;
+    }
+    isKnown(kind, name, value) {
+        const nameToValue = this.known.get(kind) ?? new Set();
+        this.known.set(kind, nameToValue);
+        if (nameToValue.has(name)) {
+            return true;
+        }
+        nameToValue.add(name);
+        return false;
+    }
     add(kind, name, value, trustedValueFn) {
-        if (this.known.has(name)) {
+        // TemplateDefinitionBuilder puts duplicate attribute, class, and style values into the consts
+        // array. This seems inefficient, we can probably keep just the first one or the last value
+        // (whichever actually gets applied when multiple values are listed for the same attribute).
+        const allowDuplicates = this.compatibility === CompatibilityMode.TemplateDefinitionBuilder &&
+            (kind === BindingKind.Attribute || kind === BindingKind.ClassName ||
+                kind === BindingKind.StyleProperty);
+        if (!allowDuplicates && this.isKnown(kind, name, value)) {
             return;
         }
-        this.known.add(name);
         // TODO: Can this be its own phase
         if (name === 'ngProjectAs') {
             if (value === null || !(value instanceof LiteralExpr) || (value.value == null) ||
@@ -11970,7 +12010,7 @@ class ElementAttributes {
  * Gets an array of literal expressions representing the attribute's namespaced name.
  */
 function getAttributeNameLiterals$1(name) {
-    const [attributeNamespace, attributeName] = splitNsName(name);
+    const [attributeNamespace, attributeName] = splitNsName(name, false);
     const nameLiteral = literal(attributeName);
     if (attributeNamespace) {
         return [
@@ -12043,7 +12083,7 @@ function convertI18nBindings(job) {
                         if (op.expression.i18nPlaceholders.length !== op.expression.expressions.length) {
                             throw new Error(`AssertionError: An i18n attribute binding instruction requires the same number of expressions and placeholders, but found ${op.expression.i18nPlaceholders.length} placeholders and ${op.expression.expressions.length} expressions`);
                         }
-                        ops.push(createI18nExpressionOp(op.i18nContext, i18nAttributesForElem.target, i18nAttributesForElem.xref, i18nAttributesForElem.handle, expr, op.expression.i18nPlaceholders[i], I18nParamResolutionTime.Creation, I18nExpressionFor.I18nAttribute, op.name, op.sourceSpan));
+                        ops.push(createI18nExpressionOp(op.i18nContext, i18nAttributesForElem.target, i18nAttributesForElem.xref, i18nAttributesForElem.handle, expr, null, op.expression.i18nPlaceholders[i], I18nParamResolutionTime.Creation, I18nExpressionFor.I18nAttribute, op.name, op.sourceSpan));
                     }
                     OpList.replaceWithMany(op, ops);
                     break;
@@ -12080,7 +12120,8 @@ function createDeferDepsFns(job) {
                 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`);
+                op.resolverFn = job.pool.getSharedFunctionReference(depsFnExpr, `${job.componentName}_Defer_${op.handle.slot}_DepsFn`, 
+                /* Don't use unique names for TDB compatibility */ false);
             }
         }
     }
@@ -12097,75 +12138,119 @@ function createDeferDepsFns(job) {
  * message.)
  */
 function createI18nContexts(job) {
-    const rootContexts = new Map();
-    let currentI18nOp = null;
-    let xref;
-    // We use the message instead of the message ID, because placeholder values might differ even
-    // when IDs are the same.
-    const messageToContext = new Map();
+    // Create i18n context ops for i18n attrs.
+    const attrContextByMessage = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            switch (op.kind) {
+                case OpKind.Binding:
+                case OpKind.Property:
+                case OpKind.Attribute:
+                case OpKind.ExtractedAttribute:
+                    if (op.i18nMessage === null) {
+                        continue;
+                    }
+                    if (!attrContextByMessage.has(op.i18nMessage)) {
+                        const i18nContext = createI18nContextOp(I18nContextKind.Attr, job.allocateXrefId(), null, op.i18nMessage, null);
+                        unit.create.push(i18nContext);
+                        attrContextByMessage.set(op.i18nMessage, i18nContext.xref);
+                    }
+                    op.i18nContext = attrContextByMessage.get(op.i18nMessage);
+                    break;
+            }
+        }
+    }
+    // Create i18n context ops for root i18n blocks.
+    const blockContextByI18nBlock = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
-                    currentI18nOp = op;
-                    // Each root i18n block gets its own context, child ones refer to the context for their
-                    // root block.
                     if (op.xref === op.root) {
-                        xref = job.allocateXrefId();
-                        unit.create.push(createI18nContextOp(I18nContextKind.RootI18n, xref, op.xref, op.message, null));
-                        op.context = xref;
-                        rootContexts.set(op.xref, xref);
+                        const contextOp = createI18nContextOp(I18nContextKind.RootI18n, job.allocateXrefId(), op.xref, op.message, null);
+                        unit.create.push(contextOp);
+                        op.context = contextOp.xref;
+                        blockContextByI18nBlock.set(op.xref, contextOp);
                     }
                     break;
+            }
+        }
+    }
+    // Assign i18n contexts for child i18n blocks. These don't need their own conext, instead they
+    // should inherit from their root i18n block.
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.I18nStart && op.xref !== op.root) {
+                const rootContext = blockContextByI18nBlock.get(op.root);
+                if (rootContext === undefined) {
+                    throw Error('AssertionError: Root i18n block i18n context should have been created.');
+                }
+                op.context = rootContext.xref;
+                blockContextByI18nBlock.set(op.xref, rootContext);
+            }
+        }
+    }
+    // Create or assign i18n contexts for ICUs.
+    let currentI18nOp = null;
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    currentI18nOp = op;
+                    break;
                 case OpKind.I18nEnd:
                     currentI18nOp = null;
                     break;
                 case OpKind.IcuStart:
-                    // 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.');
+                        throw Error('AssertionError: 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(I18nContextKind.Icu, xref, currentI18nOp.xref, op.message, null));
-                        op.context = xref;
+                        // This ICU is a sub-message inside its parent i18n block message. We need to give it
+                        // its own context.
+                        const contextOp = createI18nContextOp(I18nContextKind.Icu, job.allocateXrefId(), currentI18nOp.xref, op.message, null);
+                        unit.create.push(contextOp);
+                        op.context = contextOp.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.
+                        // This ICU is the only translatable content in its parent i18n block. We need to
+                        // convert the parent's context into an ICU context.
                         op.context = currentI18nOp.context;
+                        blockContextByI18nBlock.get(currentI18nOp.xref).contextKind = I18nContextKind.Icu;
                     }
                     break;
             }
         }
-        for (const op of unit.ops()) {
-            switch (op.kind) {
-                case OpKind.Binding:
-                case OpKind.Property:
-                case OpKind.Attribute:
-                case OpKind.ExtractedAttribute:
-                    if (!op.i18nMessage) {
-                        continue;
-                    }
-                    if (!messageToContext.has(op.i18nMessage)) {
-                        // create the context
-                        const i18nContext = job.allocateXrefId();
-                        unit.create.push(createI18nContextOp(I18nContextKind.Attr, i18nContext, null, op.i18nMessage, null));
-                        messageToContext.set(op.i18nMessage, i18nContext);
-                    }
-                    op.i18nContext = messageToContext.get(op.i18nMessage);
-                    break;
-            }
-        }
     }
-    // Assign contexts to child i18n blocks, now that all root i18n blocks have their context
-    // assigned.
+}
+
+/**
+ * Deduplicate text bindings, e.g. <div class="cls1" class="cls2">
+ */
+function deduplicateTextBindings(job) {
+    const seen = new Map();
     for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart && op.xref !== op.root) {
-                op.context = rootContexts.get(op.root);
+        for (const op of unit.update.reversed()) {
+            if (op.kind === OpKind.Binding && op.isTextAttribute) {
+                const seenForElement = seen.get(op.target) || new Set();
+                if (seenForElement.has(op.name)) {
+                    if (job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
+                        // For most duplicated attributes, TemplateDefinitionBuilder lists all of the values in
+                        // the consts array. However, for style and class attributes it only keeps the last one.
+                        // We replicate that behavior here since it has actual consequences for apps with
+                        // duplicate class or style attrs.
+                        if (op.name === 'style' || op.name === 'class') {
+                            OpList.remove(op);
+                        }
+                    }
+                    else {
+                        // TODO: Determine the correct behavior. It would probably make sense to merge multiple
+                        // style and class attributes. Alternatively we could just throw an error, as HTML
+                        // doesn't permit duplicate attributes.
+                    }
+                }
+                seenForElement.add(op.name);
+                seen.set(op.target, seenForElement);
             }
         }
     }
@@ -12551,13 +12636,18 @@ const LIST_DELIMITER = '|';
  * used in the final output.
  */
 function extractI18nMessages(job) {
-    // Save the i18n start and i18n context ops for later use.
-    const i18nContexts = new Map();
+    // Create an i18n message for each context.
+    // TODO: Merge the context op with the message op since they're 1:1 anyways.
+    const i18nMessagesByContext = new Map();
     const i18nBlocks = new Map();
+    const i18nContexts = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nContext:
+                    const i18nMessageOp = createI18nMessage(job, op);
+                    unit.create.push(i18nMessageOp);
+                    i18nMessagesByContext.set(op.xref, i18nMessageOp);
                     i18nContexts.set(op.xref, op);
                     break;
                 case OpKind.I18nStart:
@@ -12566,54 +12656,47 @@ function extractI18nMessages(job) {
             }
         }
     }
-    // TODO: Miles and I think that contexts have a 1-to-1 correspondence with extracted messages, so
-    // this phase can probably be simplified.
-    // Extract messages from contexts of i18n attributes.
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind !== OpKind.I18nContext || op.contextKind !== I18nContextKind.Attr) {
-                continue;
-            }
-            const i18nMessageOp = createI18nMessage(job, op);
-            unit.create.push(i18nMessageOp);
-        }
-    }
-    // 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.
+    // Associate sub-messages for ICUs with their root message. At this point we can also remove the
+    // ICU start/end ops, as they are no longer needed.
+    let currentIcu = null;
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.IcuStart:
-                    if (!op.context) {
-                        throw Error('ICU op should have its context set.');
+                    currentIcu = op;
+                    OpList.remove(op);
+                    // Skip any contexts not associated with an ICU.
+                    const icuContext = i18nContexts.get(op.context);
+                    if (icuContext.contextKind !== I18nContextKind.Icu) {
+                        continue;
                     }
-                    const i18nContext = i18nContexts.get(op.context);
-                    if (i18nContext.contextKind === I18nContextKind.Icu) {
-                        if (i18nContext.i18nBlock === null) {
-                            throw Error('ICU context should have its i18n block set.');
-                        }
-                        const subMessage = createI18nMessage(job, i18nContext, op.messagePlaceholder);
-                        unit.create.push(subMessage);
-                        const rootI18nId = i18nBlocks.get(i18nContext.i18nBlock).root;
-                        const parentMessage = i18nBlockMessages.get(rootI18nId);
-                        parentMessage?.subMessages.push(subMessage.xref);
+                    // Skip ICUs that share a context with their i18n message. These represent root-level
+                    // ICUs, not sub-messages.
+                    const i18nBlock = i18nBlocks.get(icuContext.i18nBlock);
+                    if (i18nBlock.context === icuContext.xref) {
+                        continue;
                     }
-                    OpList.remove(op);
+                    // Find the root message and push this ICUs message as a sub-message.
+                    const rootI18nBlock = i18nBlocks.get(i18nBlock.root);
+                    const rootMessage = i18nMessagesByContext.get(rootI18nBlock.context);
+                    if (rootMessage === undefined) {
+                        throw Error('AssertionError: ICU sub-message should belong to a root message.');
+                    }
+                    const subMessage = i18nMessagesByContext.get(icuContext.xref);
+                    subMessage.messagePlaceholder = op.messagePlaceholder;
+                    rootMessage.subMessages.push(subMessage.xref);
                     break;
                 case OpKind.IcuEnd:
+                    currentIcu = null;
+                    OpList.remove(op);
+                    break;
+                case OpKind.IcuPlaceholder:
+                    // Add ICU placeholders to the message, then remove the ICU placeholder ops.
+                    if (currentIcu === null || currentIcu.context == null) {
+                        throw Error('AssertionError: Unexpected ICU placeholder outside of i18n context');
+                    }
+                    const msg = i18nMessagesByContext.get(currentIcu.context);
+                    msg.postprocessingParams.set(op.name, literal(formatIcuPlaceholder(op)));
                     OpList.remove(op);
                     break;
             }
@@ -12626,14 +12709,19 @@ function extractI18nMessages(job) {
 function createI18nMessage(job, context, messagePlaceholder) {
     let formattedParams = formatParams(context.params);
     const formattedPostprocessingParams = formatParams(context.postprocessingParams);
-    let needsPostprocessing = formattedPostprocessingParams.size > 0;
-    for (const values of context.params.values()) {
-        if (values.length > 1) {
-            needsPostprocessing = true;
-        }
-    }
+    let needsPostprocessing = [...context.params.values()].some(v => v.length > 1);
     return createI18nMessageOp(job.allocateXrefId(), context.xref, context.i18nBlock, context.message, messagePlaceholder ?? null, formattedParams, formattedPostprocessingParams, needsPostprocessing);
 }
+/**
+ * Formats an ICU placeholder into a single string with expression placeholders.
+ */
+function formatIcuPlaceholder(op) {
+    if (op.strings.length !== op.expressionPlaceholders.length + 1) {
+        throw Error(`AsserionError: Invalid ICU placeholder with ${op.strings.length} strings and ${op.expressionPlaceholders.length} expressions`);
+    }
+    const values = op.expressionPlaceholders.map(formatValue);
+    return op.strings.flatMap((str, i) => [str, values[i] || '']).join('');
+}
 /**
  * Formats a map of `I18nParamValue[]` values into a map of `Expression` values.
  */
@@ -12972,7 +13060,7 @@ const BANG_IMPORTANT = '!important';
  */
 function parseHostStyleProperties(job) {
     for (const op of job.root.update) {
-        if (op.kind !== OpKind.Binding) {
+        if (!(op.kind === OpKind.Binding && op.bindingKind === BindingKind.Property)) {
             continue;
         }
         if (op.name.endsWith(BANG_IMPORTANT)) {
@@ -20130,7 +20218,7 @@ function collectMessage(job, fileBasedI18nSuffix, messages, messageOp) {
     let transformFn = undefined;
     // If nescessary, add a post-processing step and resolve any placeholder params that are
     // set in post-processing.
-    if (messageOp.needsPostprocessing) {
+    if (messageOp.needsPostprocessing || messageOp.postprocessingParams.size > 0) {
         // Sort the post-processing params for consistency with TemaplateDefinitionBuilder output.
         const postprocessingParams = Object.fromEntries([...messageOp.postprocessingParams.entries()].sort());
         const formattedPostprocessingParams = formatI18nPlaceholderNamesInMap(postprocessingParams, /* useCamelCase */ false);
@@ -20160,7 +20248,6 @@ function addSubMessageParams(messageOp, subMessagePlaceholders) {
         else {
             messageOp.params.set(placeholder, literal(`${ESCAPE}${I18N_ICU_MAPPING_PREFIX}${placeholder}${ESCAPE}`));
             messageOp.postprocessingParams.set(placeholder, literalArr(subMessages));
-            messageOp.needsPostprocessing = true;
         }
     }
 }
@@ -20246,6 +20333,7 @@ function convertI18nText(job) {
         let currentIcu = null;
         const textNodeI18nBlocks = new Map();
         const textNodeIcus = new Map();
+        const icuPlaceholderByText = new Map();
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
@@ -20270,7 +20358,19 @@ function convertI18nText(job) {
                     if (currentI18n !== null) {
                         textNodeI18nBlocks.set(op.xref, currentI18n);
                         textNodeIcus.set(op.xref, currentIcu);
-                        OpList.remove(op);
+                        if (op.icuPlaceholder !== null) {
+                            // Create an op to represent the ICU placeholder. Initially set its static text to the
+                            // value of the text op, though this may be overwritten later if this text op is a
+                            // placeholder for an interpolation.
+                            const icuPlaceholderOp = createIcuPlaceholderOp(job.allocateXrefId(), op.icuPlaceholder, [op.initialValue]);
+                            OpList.replace(op, icuPlaceholderOp);
+                            icuPlaceholderByText.set(op.xref, icuPlaceholderOp);
+                        }
+                        else {
+                            // Otherwise just remove the text op, since its value is already accounted for in the
+                            // translated message.
+                            OpList.remove(op);
+                        }
                     }
                     break;
             }
@@ -20285,6 +20385,7 @@ function convertI18nText(job) {
                     }
                     const i18nOp = textNodeI18nBlocks.get(op.target);
                     const icuOp = textNodeIcus.get(op.target);
+                    const icuPlaceholder = icuPlaceholderByText.get(op.target);
                     const contextId = icuOp ? icuOp.context : i18nOp.context;
                     const resolutionTime = icuOp ? I18nParamResolutionTime.Postproccessing :
                         I18nParamResolutionTime.Creation;
@@ -20293,9 +20394,14 @@ function convertI18nText(job) {
                         const expr = op.interpolation.expressions[i];
                         // 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(contextId, i18nOp.xref, i18nOp.xref, i18nOp.handle, expr, op.interpolation.i18nPlaceholders[i], resolutionTime, I18nExpressionFor.I18nText, '', expr.sourceSpan ?? op.sourceSpan));
+                        ops.push(createI18nExpressionOp(contextId, i18nOp.xref, i18nOp.xref, i18nOp.handle, expr, icuPlaceholder?.xref ?? null, op.interpolation.i18nPlaceholders[i] ?? null, resolutionTime, I18nExpressionFor.I18nText, '', expr.sourceSpan ?? op.sourceSpan));
                     }
                     OpList.replaceWithMany(op, ops);
+                    // If this interpolation is part of an ICU placeholder, add the strings and expressions to
+                    // the placeholder.
+                    if (icuPlaceholder !== undefined) {
+                        icuPlaceholder.strings = op.interpolation.strings;
+                    }
                     break;
             }
         }
@@ -20824,10 +20930,28 @@ function keepLast(ops) {
  * class property.
  */
 function parseExtractedStyles(job) {
+    const elements = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (isElementOrContainerOp(op)) {
+                elements.set(op.xref, op);
+            }
+        }
+    }
     for (const unit of job.units) {
         for (const op of unit.create) {
             if (op.kind === OpKind.ExtractedAttribute && op.bindingKind === BindingKind.Attribute &&
                 isStringLiteral(op.expression)) {
+                const target = elements.get(op.target);
+                if (target !== undefined && target.kind === OpKind.Template &&
+                    target.templateKind === TemplateKind.Structural) {
+                    // TemplateDefinitionBuilder will not apply class and style bindings to structural
+                    // directives; instead, it will leave them as attributes.
+                    // (It's not clear what that would mean, anyway -- classes and styles on a structural
+                    // element should probably be a parse error.)
+                    // TODO: We may be able to remove this once Template Pipeline is the default.
+                    continue;
+                }
                 if (op.name === 'style') {
                     const parsedStyles = parse(op.expression.value);
                     for (let i = 0; i < parsedStyles.length - 1; i += 2) {
@@ -21719,19 +21843,19 @@ function reifyCreateOperations(unit, ops) {
                 OpList.replace(op, text(op.handle.slot, op.initialValue, op.sourceSpan));
                 break;
             case OpKind.ElementStart:
-                OpList.replace(op, elementStart(op.handle.slot, op.tag, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, elementStart(op.handle.slot, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.Element:
-                OpList.replace(op, element(op.handle.slot, op.tag, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, element(op.handle.slot, op.tag, op.attributes, op.localRefs, op.wholeSourceSpan));
                 break;
             case OpKind.ElementEnd:
                 OpList.replace(op, elementEnd(op.sourceSpan));
                 break;
             case OpKind.ContainerStart:
-                OpList.replace(op, elementContainerStart(op.handle.slot, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, elementContainerStart(op.handle.slot, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.Container:
-                OpList.replace(op, elementContainer(op.handle.slot, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, elementContainer(op.handle.slot, op.attributes, op.localRefs, op.wholeSourceSpan));
                 break;
             case OpKind.ContainerEnd:
                 OpList.replace(op, elementContainerEnd());
@@ -21759,7 +21883,7 @@ function reifyCreateOperations(unit, ops) {
                     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.localRefs, op.sourceSpan));
+                OpList.replace(op, template(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.DisableBindings:
                 OpList.replace(op, disableBindings());
@@ -21774,7 +21898,7 @@ function reifyCreateOperations(unit, ops) {
                 const listenerFn = reifyListenerHandler(unit, op.handlerFnName, op.handlerOps, op.consumesDollarEvent);
                 const eventTargetResolver = op.eventTarget ? GLOBAL_TARGET_RESOLVERS$1.get(op.eventTarget) : null;
                 if (eventTargetResolver === undefined) {
-                    throw new Error(`AssertionError: unknown event target ${op.eventTarget}`);
+                    throw new Error(`Unexpected global target '${op.eventTarget}' defined for '${op.name}' event. Supported list of global targets: window,document,body.`);
                 }
                 OpList.replace(op, listener(op.name, listenerFn, eventTargetResolver, op.hostListener && op.isAnimationListener, op.sourceSpan));
                 break;
@@ -21861,7 +21985,7 @@ function reifyCreateOperations(unit, ops) {
                     emptyDecls = emptyView.decls;
                     emptyVars = emptyView.vars;
                 }
-                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.sourceSpan));
+                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.wholeSourceSpan));
                 break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
@@ -22491,6 +22615,7 @@ function resolveI18nExpressionPlaceholders(job) {
     // Record all of the i18n context ops, and the sub-template index for each i18n op.
     const subTemplateIndicies = new Map();
     const i18nContexts = new Map();
+    const icuPlaceholders = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
@@ -22500,6 +22625,9 @@ function resolveI18nExpressionPlaceholders(job) {
                 case OpKind.I18nContext:
                     i18nContexts.set(op.xref, op);
                     break;
+                case OpKind.IcuPlaceholder:
+                    icuPlaceholders.set(op.xref, op);
+                    break;
             }
         }
     }
@@ -22513,76 +22641,32 @@ function resolveI18nExpressionPlaceholders(job) {
     for (const unit of job.units) {
         for (const op of unit.update) {
             if (op.kind === OpKind.I18nExpression) {
-                const i18nContext = i18nContexts.get(op.context);
                 const index = expressionIndices.get(referenceIndex(op)) || 0;
                 const subTemplateIndex = subTemplateIndicies.get(op.i18nOwner) ?? null;
-                // Add the expression index in the appropriate params map.
-                const params = op.resolutionTime === I18nParamResolutionTime.Creation ?
-                    i18nContext.params :
-                    i18nContext.postprocessingParams;
-                const values = params.get(op.i18nPlaceholder) || [];
-                values.push({
+                const value = {
                     value: index,
                     subTemplateIndex: subTemplateIndex,
                     flags: I18nParamValueFlags.ExpressionIndex
-                });
-                params.set(op.i18nPlaceholder, values);
+                };
+                updatePlaceholder(op, value, i18nContexts, icuPlaceholders);
                 expressionIndices.set(referenceIndex(op), index + 1);
             }
         }
     }
 }
-
-/**
- * Resolves placeholders for element tags inside of an ICU.
- */
-function resolveI18nIcuPlaceholders(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nContext && op.contextKind === I18nContextKind.Icu) {
-                for (const node of op.message.nodes) {
-                    node.visit(new ResolveIcuPlaceholdersVisitor(op.postprocessingParams));
-                }
-            }
-        }
-    }
-}
-/**
- * Visitor for i18n AST that resolves ICU params into the given map.
- */
-class ResolveIcuPlaceholdersVisitor extends RecurseVisitor {
-    constructor(params) {
-        super();
-        this.params = params;
-    }
-    visitContainerPlaceholder(placeholder) {
-        // Add the start and end source span for container placeholders. These need to be recorded for
-        // elements inside ICUs. The slots for the nodes were recorded separately under the i18n
-        // block's context as part of the `resolveI18nElementPlaceholders` phase.
-        if (placeholder.startName && placeholder.startSourceSpan &&
-            !this.params.has(placeholder.startName)) {
-            this.params.set(placeholder.startName, [{
-                    value: placeholder.startSourceSpan?.toString(),
-                    subTemplateIndex: null,
-                    flags: I18nParamValueFlags.None
-                }]);
-        }
-        if (placeholder.closeName && placeholder.endSourceSpan &&
-            !this.params.has(placeholder.closeName)) {
-            this.params.set(placeholder.closeName, [{
-                    value: placeholder.endSourceSpan?.toString(),
-                    subTemplateIndex: null,
-                    flags: I18nParamValueFlags.None
-                }]);
-        }
-    }
-    visitTagPlaceholder(placeholder) {
-        super.visitTagPlaceholder(placeholder);
-        this.visitContainerPlaceholder(placeholder);
+function updatePlaceholder(op, value, i18nContexts, icuPlaceholders) {
+    if (op.i18nPlaceholder !== null) {
+        const i18nContext = i18nContexts.get(op.context);
+        const params = op.resolutionTime === I18nParamResolutionTime.Creation ?
+            i18nContext.params :
+            i18nContext.postprocessingParams;
+        const values = params.get(op.i18nPlaceholder) || [];
+        values.push(value);
+        params.set(op.i18nPlaceholder, values);
     }
-    visitBlockPlaceholder(placeholder) {
-        super.visitBlockPlaceholder(placeholder);
-        this.visitContainerPlaceholder(placeholder);
+    if (op.icuPlaceholder !== null) {
+        const icuPlaceholderOp = icuPlaceholders.get(op.icuPlaceholder);
+        icuPlaceholderOp?.expressionPlaceholders.push(value);
     }
 }
 
@@ -23257,7 +23341,14 @@ function varsUsedByOp(op) {
             return op.interpolation.expressions.length;
         case OpKind.I18nExpression:
         case OpKind.Conditional:
+        case OpKind.DeferWhen:
             return 1;
+        case OpKind.RepeaterCreate:
+            // Repeaters may require an extra variable binding slot, if they have an empty view, for the
+            // empty block tracking.
+            // TODO: It's a bit odd to have a create mode instruction consume variable slots. Maybe we can
+            // find a way to use the Repeater update op instead.
+            return op.emptyView ? 1 : 0;
         default:
             throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
     }
@@ -23741,6 +23832,7 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: emitNamespaceChanges },
     { kind: CompilationJobKind.Tmpl, fn: propagateI18nBlocks },
     { kind: CompilationJobKind.Tmpl, fn: wrapI18nIcus },
+    { kind: CompilationJobKind.Both, fn: deduplicateTextBindings },
     { kind: CompilationJobKind.Both, fn: specializeStyleBindings },
     { kind: CompilationJobKind.Both, fn: specializeBindings },
     { kind: CompilationJobKind.Both, fn: extractAttributes },
@@ -23779,7 +23871,6 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: createDeferDepsFns },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nElementPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nExpressionPlaceholders },
-    { kind: CompilationJobKind.Tmpl, fn: resolveI18nIcuPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: extractI18nMessages },
     { kind: CompilationJobKind.Tmpl, fn: generateTrackFns },
     { kind: CompilationJobKind.Tmpl, fn: collectI18nConsts },
@@ -23939,7 +24030,7 @@ function ingestHostBinding(input, bindingParser, constantPool) {
         const securityContexts = bindingParser
             .calcPossibleSecurityContexts(input.componentSelector, property.name, bindingKind === BindingKind.Attribute)
             .filter(context => context !== SecurityContext.NONE);
-        ingestHostProperty(job, property, bindingKind, false, securityContexts);
+        ingestHostProperty(job, property, bindingKind, securityContexts);
     }
     for (const [name, expr] of Object.entries(input.attributes) ?? []) {
         const securityContexts = bindingParser.calcPossibleSecurityContexts(input.componentSelector, name, true)
@@ -23953,7 +24044,7 @@ function ingestHostBinding(input, bindingParser, constantPool) {
 }
 // TODO: We should refactor the parser to use the same types and structures for host bindings as
 // with ordinary components. This would allow us to share a lot more ingestion code.
-function ingestHostProperty(job, property, bindingKind, isTextAttribute, securityContexts) {
+function ingestHostProperty(job, property, bindingKind, securityContexts) {
     let expression;
     const ast = property.expression.ast;
     if (ast instanceof Interpolation$1) {
@@ -23962,20 +24053,21 @@ function ingestHostProperty(job, property, bindingKind, isTextAttribute, securit
     else {
         expression = convertAst(ast, job, property.sourceSpan);
     }
-    job.root.update.push(createBindingOp(job.root.xref, bindingKind, property.name, expression, null, securityContexts, isTextAttribute, false, null, /* TODO: How do Host bindings handle i18n attrs? */ null, property.sourceSpan));
+    job.root.update.push(createBindingOp(job.root.xref, bindingKind, property.name, expression, null, securityContexts, false, false, null, /* TODO: How do Host bindings handle i18n attrs? */ null, property.sourceSpan));
 }
 function ingestHostAttribute(job, name, value, securityContexts) {
-    const attrBinding = createBindingOp(job.root.xref, BindingKind.Attribute, name, value, null, securityContexts, true, false, null, 
+    const attrBinding = createBindingOp(job.root.xref, BindingKind.Attribute, name, value, null, securityContexts, 
+    /* Host attributes should always be extracted to const hostAttrs, even if they are not
+     *strictly* text literals */
+    true, false, null, 
     /* TODO */ null, 
-    /* TODO: host attribute source spans */ null);
+    /** TODO: May be null? */ value.sourceSpan);
     job.root.update.push(attrBinding);
 }
 function ingestHostEvent(job, event) {
     const [phase, target] = event.type === 0 /* e.ParsedEventType.Regular */ ? [null, event.targetOrPhase] :
         [event.targetOrPhase, null];
-    const eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, [], phase, target, true, event.sourceSpan);
-    // TODO: Can this be a chain?
-    eventBinding.handlerOps.push(createStatementOp(new ReturnStatement(convertAst(event.handler.ast, job, event.sourceSpan), event.handlerSpan)));
+    const eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, makeListenerHandlerOps(job.root, event.handler, event.handlerSpan), phase, target, true, event.sourceSpan);
     job.root.create.push(eventBinding);
 }
 /**
@@ -23993,10 +24085,10 @@ function ingestNodes(unit, template) {
             ingestContent(unit, node);
         }
         else if (node instanceof Text$3) {
-            ingestText(unit, node);
+            ingestText(unit, node, null);
         }
         else if (node instanceof BoundText) {
-            ingestBoundText(unit, node);
+            ingestBoundText(unit, node, null);
         }
         else if (node instanceof IfBlock) {
             ingestIfBlock(unit, node);
@@ -24028,7 +24120,7 @@ function ingestElement(unit, element) {
     }
     const id = unit.job.allocateXrefId();
     const [namespaceKey, elementName] = splitNsName(element.name);
-    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n instanceof TagPlaceholder ? element.i18n : undefined, element.startSourceSpan);
+    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n instanceof TagPlaceholder ? element.i18n : undefined, element.startSourceSpan, element.sourceSpan);
     unit.create.push(startOp);
     ingestElementBindings(unit, startOp, element);
     ingestReferences(startOp, element);
@@ -24071,7 +24163,7 @@ function ingestTemplate(unit, tmpl) {
         '' :
         prefixWithNamespace(tagNameWithoutNamespace, namespace);
     const templateKind = isPlainTemplate(tmpl) ? TemplateKind.NgTemplate : TemplateKind.Structural;
-    const templateOp = createTemplateOp(childView.xref, templateKind, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan);
+    const templateOp = createTemplateOp(childView.xref, templateKind, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan, tmpl.sourceSpan);
     unit.create.push(templateOp);
     ingestTemplateBindings(unit, templateOp, tmpl, templateKind);
     ingestReferences(templateOp, tmpl);
@@ -24106,13 +24198,13 @@ function ingestContent(unit, content) {
 /**
  * Ingest a literal text node from the AST into the given `ViewCompilation`.
  */
-function ingestText(unit, text) {
-    unit.create.push(createTextOp(unit.job.allocateXrefId(), text.value, text.sourceSpan));
+function ingestText(unit, text, icuPlaceholder) {
+    unit.create.push(createTextOp(unit.job.allocateXrefId(), text.value, icuPlaceholder, text.sourceSpan));
 }
 /**
  * Ingest an interpolated text node from the AST into the given `ViewCompilation`.
  */
-function ingestBoundText(unit, text, i18nPlaceholders) {
+function ingestBoundText(unit, text, icuPlaceholder) {
     let value = text.value;
     if (value instanceof ASTWithSource) {
         value = value.ast;
@@ -24123,19 +24215,16 @@ function ingestBoundText(unit, text, i18nPlaceholders) {
     if (text.i18n !== undefined && !(text.i18n instanceof Container)) {
         throw Error(`Unhandled i18n metadata type for text interpolation: ${text.i18n?.constructor.name}`);
     }
-    if (i18nPlaceholders === undefined) {
-        // TODO: We probably can just use the placeholders field, instead of walking the AST.
-        i18nPlaceholders = text.i18n instanceof Container ?
-            text.i18n.children
-                .filter((node) => node instanceof Placeholder)
-                .map(placeholder => placeholder.name) :
-            [];
-    }
+    const i18nPlaceholders = text.i18n instanceof Container ?
+        text.i18n.children
+            .filter((node) => node instanceof Placeholder)
+            .map(placeholder => placeholder.name) :
+        [];
     if (i18nPlaceholders.length > 0 && i18nPlaceholders.length !== value.expressions.length) {
         throw Error(`Unexpected number of i18n placeholders (${value.expressions.length}) for BoundText with ${value.expressions.length} expressions`);
     }
     const textXref = unit.job.allocateXrefId();
-    unit.create.push(createTextOp(textXref, '', text.sourceSpan));
+    unit.create.push(createTextOp(textXref, '', icuPlaceholder, text.sourceSpan));
     // TemplateDefinitionBuilder does not generate source maps for sub-expressions inside an
     // interpolation. We copy that behavior in compatibility mode.
     // TODO: is it actually correct to generate these extra maps in modern mode?
@@ -24168,7 +24257,7 @@ function ingestIfBlock(unit, ifBlock) {
             }
             ifCaseI18nMeta = ifCase.i18n;
         }
-        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, 'Conditional', Namespace.HTML, ifCaseI18nMeta, ifCase.sourceSpan);
+        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, 'Conditional', Namespace.HTML, ifCaseI18nMeta, ifCase.startSourceSpan, ifCase.sourceSpan);
         unit.create.push(templateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
@@ -24198,7 +24287,7 @@ function ingestSwitchBlock(unit, switchBlock) {
             }
             switchCaseI18nMeta = switchCase.i18n;
         }
-        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, null, 'Case', Namespace.HTML, switchCaseI18nMeta, switchCase.sourceSpan);
+        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, null, 'Case', Namespace.HTML, switchCaseI18nMeta, switchCase.startSourceSpan, switchCase.sourceSpan);
         unit.create.push(templateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
@@ -24223,7 +24312,7 @@ function ingestDeferView(unit, suffix, i18nMeta, children, sourceSpan) {
     }
     const secondaryView = unit.job.allocateView(unit.xref);
     ingestNodes(secondaryView, children);
-    const templateOp = createTemplateOp(secondaryView.xref, TemplateKind.Block, null, `Defer${suffix}`, Namespace.HTML, i18nMeta, sourceSpan);
+    const templateOp = createTemplateOp(secondaryView.xref, TemplateKind.Block, null, `Defer${suffix}`, Namespace.HTML, i18nMeta, sourceSpan, sourceSpan);
     unit.create.push(templateOp);
     return templateOp;
 }
@@ -24301,6 +24390,11 @@ function ingestDeferBlock(unit, deferBlock) {
             deferOnOps.push(deferOnOp);
         }
         if (triggers.when !== undefined) {
+            if (triggers.when.value instanceof Interpolation$1) {
+                // TemplateDefinitionBuilder supports this case, but it's very strange to me. What would it
+                // even mean?
+                throw new Error(`Unexpected interpolation in defer block when trigger`);
+            }
             const deferOnOp = createDeferWhenOp(deferXref, convertAst(triggers.when.value, unit.job, triggers.when.sourceSpan), prefetch, triggers.when.sourceSpan);
             deferWhenOps.push(deferOnOp);
         }
@@ -24320,10 +24414,10 @@ function ingestIcu(unit, icu) {
         unit.create.push(createIcuStartOp(xref, icu.i18n, icuFromI18nMessage(icu.i18n).name, null));
         for (const [placeholder, text] of Object.entries({ ...icu.vars, ...icu.placeholders })) {
             if (text instanceof BoundText) {
-                ingestBoundText(unit, text, [placeholder]);
+                ingestBoundText(unit, text, placeholder);
             }
             else {
-                ingestText(unit, text);
+                ingestText(unit, text, placeholder);
             }
         }
         unit.create.push(createIcuEndOp(xref));
@@ -24380,7 +24474,7 @@ function ingestForBlock(unit, forBlock) {
     const i18nPlaceholder = forBlock.i18n;
     const emptyI18nPlaceholder = forBlock.empty?.i18n;
     const tagName = ingestControlFlowInsertionPoint(unit, repeaterView.xref, forBlock);
-    const repeaterCreate = createRepeaterCreateOp(repeaterView.xref, emptyView?.xref ?? null, tagName, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, forBlock.sourceSpan);
+    const repeaterCreate = createRepeaterCreateOp(repeaterView.xref, emptyView?.xref ?? null, tagName, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, forBlock.startSourceSpan, forBlock.sourceSpan);
     unit.create.push(repeaterCreate);
     const expression = convertAst(forBlock.expression, unit.job, convertSourceSpan(forBlock.expression.span, forBlock.sourceSpan));
     const repeater = createRepeaterOp(repeaterCreate.xref, repeaterCreate.handle, expression, forBlock.sourceSpan);
@@ -24498,13 +24592,13 @@ function convertAst(ast, job, baseSourceSpan) {
         throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
     }
 }
-function convertAstWithInterpolation(job, value, i18nMeta) {
+function convertAstWithInterpolation(job, value, i18nMeta, sourceSpan) {
     let expression;
     if (value instanceof Interpolation$1) {
-        expression = new Interpolation(value.strings, value.expressions.map(e => convertAst(e, job, null)), Object.keys(asMessage(i18nMeta)?.placeholders ?? {}));
+        expression = new Interpolation(value.strings, value.expressions.map(e => convertAst(e, job, sourceSpan ?? null)), Object.keys(asMessage(i18nMeta)?.placeholders ?? {}));
     }
     else if (value instanceof AST) {
-        expression = convertAst(value, job, null);
+        expression = convertAst(value, job, sourceSpan ?? null);
     }
     else {
         expression = literal(value);
@@ -29479,12 +29573,16 @@ class BindingScope {
 }
 /** Binding scope of a `track` function inside a `for` loop block. */
 class TrackByBindingScope extends BindingScope {
-    constructor(parentScope, globalAliases) {
+    constructor(parentScope, globalOverrides) {
         super(parentScope.bindingLevel + 1, parentScope);
-        this.globalAliases = globalAliases;
+        this.globalOverrides = globalOverrides;
         this.componentAccessCount = 0;
     }
     get(name) {
+        // Intercept any overridden globals.
+        if (this.globalOverrides.hasOwnProperty(name)) {
+            return variable(this.globalOverrides[name]);
+        }
         let current = this.parent;
         // Prevent accesses of template variables outside the `for` loop.
         while (current) {
@@ -29493,10 +29591,6 @@ class TrackByBindingScope extends BindingScope {
             }
             current = current.parent;
         }
-        // Intercept any aliased globals.
-        if (this.globalAliases[name]) {
-            return variable(this.globalAliases[name]);
-        }
         // When the component scope is accessed, we redirect it through `this`.
         this.componentAccessCount++;
         return variable('this').prop(name);
@@ -31994,7 +32088,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.0.7');
+const VERSION = new Version('17.0.8');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -33560,7 +33654,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.7'));
+    definitionMap.set('version', literal('17.0.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -33668,7 +33762,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.7'));
+    definitionMap.set('version', literal('17.0.8'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -33945,7 +34039,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.7'));
+    definitionMap.set('version', literal('17.0.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -33980,7 +34074,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.7'));
+    definitionMap.set('version', literal('17.0.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -34031,7 +34125,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.7'));
+    definitionMap.set('version', literal('17.0.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -34064,7 +34158,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.7'));
+    definitionMap.set('version', literal('17.0.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -34115,7 +34209,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.7'));
+    definitionMap.set('version', literal('17.0.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);