@angular/compiler 17.0.0-next.7 → 17.0.0-rc.0

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.7
+ * @license Angular v17.0.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2482,6 +2482,7 @@ class Identifiers {
     static { this.deferPrefetchOnHover = { name: 'ɵɵdeferPrefetchOnHover', moduleName: CORE }; }
     static { this.deferPrefetchOnInteraction = { name: 'ɵɵdeferPrefetchOnInteraction', moduleName: CORE }; }
     static { this.deferPrefetchOnViewport = { name: 'ɵɵdeferPrefetchOnViewport', moduleName: CORE }; }
+    static { this.deferEnableTimerScheduling = { name: 'ɵɵdeferEnableTimerScheduling', moduleName: CORE }; }
     static { this.conditional = { name: 'ɵɵconditional', moduleName: CORE }; }
     static { this.repeater = { name: 'ɵɵrepeater', moduleName: CORE }; }
     static { this.repeaterCreate = { name: 'ɵɵrepeaterCreate', moduleName: CORE }; }
@@ -2605,6 +2606,7 @@ class Identifiers {
     static { this.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE }; }
     static { this.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE }; }
     static { this.setClassMetadataAsync = { name: 'ɵsetClassMetadataAsync', moduleName: CORE }; }
+    static { this.setClassDebugInfo = { name: 'ɵsetClassDebugInfo', moduleName: CORE }; }
     static { this.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE }; }
     static { this.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE }; }
     static { this.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE }; }
@@ -3868,12 +3870,13 @@ class DeferredBlockError {
     }
 }
 class DeferredBlock {
-    constructor(children, triggers, prefetchTriggers, placeholder, loading, error, sourceSpan, startSourceSpan, endSourceSpan) {
+    constructor(children, triggers, prefetchTriggers, placeholder, loading, error, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan) {
         this.children = children;
         this.placeholder = placeholder;
         this.loading = loading;
         this.error = error;
         this.sourceSpan = sourceSpan;
+        this.mainBlockSpan = mainBlockSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
         this.triggers = triggers;
@@ -3890,20 +3893,23 @@ class DeferredBlock {
         this.visitTriggers(this.definedTriggers, this.triggers, visitor);
         this.visitTriggers(this.definedPrefetchTriggers, this.prefetchTriggers, visitor);
         visitAll$1(visitor, this.children);
-        this.placeholder && visitor.visitDeferredBlockPlaceholder(this.placeholder);
-        this.loading && visitor.visitDeferredBlockLoading(this.loading);
-        this.error && visitor.visitDeferredBlockError(this.error);
+        const remainingBlocks = [this.placeholder, this.loading, this.error].filter(x => x !== null);
+        visitAll$1(visitor, remainingBlocks);
     }
     visitTriggers(keys, triggers, visitor) {
-        for (const key of keys) {
-            visitor.visitDeferredTrigger(triggers[key]);
-        }
+        visitAll$1(visitor, keys.map(k => triggers[k]));
     }
 }
 class SwitchBlock {
-    constructor(expression, cases, sourceSpan, startSourceSpan, endSourceSpan) {
+    constructor(expression, cases, 
+    /**
+     * These blocks are only captured to allow for autocompletion in the language service. They
+     * aren't meant to be processed in any other way.
+     */
+    unknownBlocks, sourceSpan, startSourceSpan, endSourceSpan) {
         this.expression = expression;
         this.cases = cases;
+        this.unknownBlocks = unknownBlocks;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
@@ -3913,18 +3919,19 @@ class SwitchBlock {
     }
 }
 class SwitchBlockCase {
-    constructor(expression, children, sourceSpan, startSourceSpan) {
+    constructor(expression, children, sourceSpan, startSourceSpan, endSourceSpan) {
         this.expression = expression;
         this.children = children;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
     }
     visit(visitor) {
         return visitor.visitSwitchBlockCase(this);
     }
 }
 class ForLoopBlock {
-    constructor(item, expression, trackBy, contextVariables, children, empty, sourceSpan, startSourceSpan, endSourceSpan) {
+    constructor(item, expression, trackBy, contextVariables, children, empty, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan) {
         this.item = item;
         this.expression = expression;
         this.trackBy = trackBy;
@@ -3932,6 +3939,7 @@ class ForLoopBlock {
         this.children = children;
         this.empty = empty;
         this.sourceSpan = sourceSpan;
+        this.mainBlockSpan = mainBlockSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
     }
@@ -3940,10 +3948,11 @@ class ForLoopBlock {
     }
 }
 class ForLoopBlockEmpty {
-    constructor(children, sourceSpan, startSourceSpan) {
+    constructor(children, sourceSpan, startSourceSpan, endSourceSpan) {
         this.children = children;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
     }
     visit(visitor) {
         return visitor.visitForLoopBlockEmpty(this);
@@ -3961,17 +3970,27 @@ class IfBlock {
     }
 }
 class IfBlockBranch {
-    constructor(expression, children, expressionAlias, sourceSpan, startSourceSpan) {
+    constructor(expression, children, expressionAlias, sourceSpan, startSourceSpan, endSourceSpan) {
         this.expression = expression;
         this.children = children;
         this.expressionAlias = expressionAlias;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
     }
     visit(visitor) {
         return visitor.visitIfBlockBranch(this);
     }
 }
+class UnknownBlock {
+    constructor(name, sourceSpan) {
+        this.name = name;
+        this.sourceSpan = sourceSpan;
+    }
+    visit(visitor) {
+        return visitor.visitUnknownBlock(this);
+    }
+}
 class Template {
     constructor(
     // tagName is the name of the container element, if applicable.
@@ -4078,10 +4097,9 @@ class RecursiveVisitor$1 {
         visitAll$1(this, block.children);
     }
     visitForLoopBlock(block) {
-        block.item.visit(this);
-        visitAll$1(this, Object.values(block.contextVariables));
-        visitAll$1(this, block.children);
-        block.empty?.visit(this);
+        const blockItems = [block.item, ...Object.values(block.contextVariables), ...block.children];
+        block.empty && blockItems.push(block.empty);
+        visitAll$1(this, blockItems);
     }
     visitForLoopBlockEmpty(block) {
         visitAll$1(this, block.children);
@@ -4090,8 +4108,9 @@ class RecursiveVisitor$1 {
         visitAll$1(this, block.branches);
     }
     visitIfBlockBranch(block) {
-        visitAll$1(this, block.children);
-        block.expressionAlias?.visit(this);
+        const blockItems = block.children;
+        block.expressionAlias && blockItems.push(block.expressionAlias);
+        visitAll$1(this, blockItems);
     }
     visitContent(content) { }
     visitVariable(variable) { }
@@ -4103,6 +4122,7 @@ class RecursiveVisitor$1 {
     visitBoundText(text) { }
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
+    visitUnknownBlock(block) { }
 }
 function visitAll$1(visitor, nodes) {
     const result = [];
@@ -8297,7 +8317,7 @@ class ShadowCss {
             // (ie: ".\fc ber" for ".über") is not a separator between 2 selectors
             // also keep in mind that backslashes are replaced by a placeholder by SafeSelector
             // These escaped selectors happen for example when esbuild runs with optimization.minify.
-            if (part.match(_placeholderRe) && selector[res.index + 1]?.match(/[a-fA-F\d]/)) {
+            if (part.match(/__esc-ph-(\d+)__/) && selector[res.index + 1]?.match(/[a-fA-F\d]/)) {
                 continue;
             }
             shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
@@ -8328,7 +8348,13 @@ class SafeSelector {
         // pseudo-class, but writing `.foo\:blue` will match, because the colon was escaped.
         // Replace all escape sequences (`\` followed by a character) with a placeholder so
         // that our handling of pseudo-selectors doesn't mess with them.
-        selector = this._escapeRegexMatches(selector, /(\\.)/g);
+        // Escaped characters have a specific placeholder so they can be detected separately.
+        selector = selector.replace(/(\\.)/g, (_, keep) => {
+            const replaceBy = `__esc-ph-${this.index}__`;
+            this.placeholders.push(keep);
+            this.index++;
+            return replaceBy;
+        });
         // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
         // WS and "+" would otherwise be interpreted as selector separators.
         this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
@@ -8339,7 +8365,7 @@ class SafeSelector {
         });
     }
     restore(content) {
-        return content.replace(_placeholderRe, (_ph, index) => this.placeholders[+index]);
+        return content.replace(/__(?:ph|esc-ph)-(\d+)__/g, (_ph, index) => this.placeholders[+index]);
     }
     content() {
         return this._content;
@@ -8391,7 +8417,6 @@ const _commentRe = /\/\*[\s\S]*?\*\//g;
 const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=/g;
 const COMMENT_PLACEHOLDER = '%COMMENT%';
 const _commentWithHashPlaceHolderRe = new RegExp(COMMENT_PLACEHOLDER, 'g');
-const _placeholderRe = /__ph-(\d+)__/g;
 const BLOCK_PLACEHOLDER = '%BLOCK%';
 const _ruleRe = new RegExp(`(\\s*(?:${COMMENT_PLACEHOLDER}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`, 'g');
 const CONTENT_PAIRS = new Map([['{', '}']]);
@@ -8821,6 +8846,14 @@ var OpKind;
      * An instruction that applies a set of i18n expressions.
      */
     OpKind[OpKind["I18nApply"] = 38] = "I18nApply";
+    /**
+     * An instruction to create an ICU expression.
+     */
+    OpKind[OpKind["Icu"] = 39] = "Icu";
+    /**
+     * An instruction to update an ICU expression.
+     */
+    OpKind[OpKind["IcuUpdate"] = 40] = "IcuUpdate";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -8999,6 +9032,22 @@ var BindingKind;
      */
     BindingKind[BindingKind["Animation"] = 6] = "Animation";
 })(BindingKind || (BindingKind = {}));
+/**
+ * Enumeration of possible times i18n params can be resolved.
+ */
+var I18nParamResolutionTime;
+(function (I18nParamResolutionTime) {
+    /**
+     * Param is resolved at message creation time. Most params should be resolved at message creation
+     * time. However, ICU params need to be handled in post-processing.
+     */
+    I18nParamResolutionTime[I18nParamResolutionTime["Creation"] = 0] = "Creation";
+    /**
+     * Param is resolved during post-processing. This should be used for params who's value comes from
+     * an ICU.
+     */
+    I18nParamResolutionTime[I18nParamResolutionTime["Postproccessing"] = 1] = "Postproccessing";
+})(I18nParamResolutionTime || (I18nParamResolutionTime = {}));
 
 /**
  * Marker symbol for `ConsumesSlotOpTrait`.
@@ -9297,12 +9346,14 @@ function createConditionalOp(target, test, conditions, sourceSpan) {
 /**
  * Create an i18n expression op.
  */
-function createI18nExpressionOp(target, expression, i18nPlaceholder, sourceSpan) {
+function createI18nExpressionOp(owner, expression, i18nPlaceholder, resolutionTime, sourceSpan) {
     return {
         kind: OpKind.I18nExpression,
-        target,
+        owner,
+        target: owner,
         expression,
         i18nPlaceholder,
+        resolutionTime,
         sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_VARS,
@@ -9321,6 +9372,17 @@ function createI18nApplyOp(target, sourceSpan) {
         ...TRAIT_USES_SLOT_INDEX,
     };
 }
+/**
+ * Creates an op to update an ICU expression.
+ */
+function createIcuUpdateOp(xref, sourceSpan) {
+    return {
+        kind: OpKind.IcuUpdate,
+        xref,
+        sourceSpan,
+        ...NEW_OP,
+    };
+}
 
 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
 /**
@@ -10043,6 +10105,8 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Advance:
         case OpKind.Namespace:
         case OpKind.I18nApply:
+        case OpKind.Icu:
+        case OpKind.IcuUpdate:
             // These operations contain no expressions.
             break;
         default:
@@ -10448,7 +10512,7 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan)
 /**
  * Create a `TemplateOp`.
  */
-function createTemplateOp(xref, tag, namespace, generatedInBlock, i18n, sourceSpan) {
+function createTemplateOp(xref, tag, namespace, generatedInBlock, i18nPlaceholder, sourceSpan) {
     return {
         kind: OpKind.Template,
         xref,
@@ -10460,6 +10524,7 @@ function createTemplateOp(xref, tag, namespace, generatedInBlock, i18n, sourceSp
         localRefs: [],
         nonBindable: false,
         namespace,
+        i18nPlaceholder,
         sourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
@@ -10633,13 +10698,17 @@ function createExtractedMessageOp(owner, expression, statements) {
 /**
  * Create an `I18nStartOp`.
  */
-function createI18nStartOp(xref, message) {
+function createI18nStartOp(xref, message, root) {
     return {
         kind: OpKind.I18nStart,
         xref,
+        root: root ?? xref,
         message,
         params: new Map(),
+        postprocessingParams: new Map(),
         messageIndex: null,
+        subTemplateIndex: null,
+        needsPostprocessing: false,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -10654,6 +10723,18 @@ function createI18nEndOp(xref) {
         ...NEW_OP,
     };
 }
+/**
+ * Creates an op to create an ICU expression.
+ */
+function createIcuOp(xref, message, sourceSpan) {
+    return {
+        kind: OpKind.Icu,
+        xref,
+        message,
+        sourceSpan,
+        ...NEW_OP,
+    };
+}
 function literalOrArrayLiteral$1(value) {
     if (Array.isArray(value)) {
         return literalArr(value.map(literalOrArrayLiteral$1));
@@ -11019,7 +11100,7 @@ function phaseApplyI18nExpressions(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.target, null), op);
+                OpList.insertAfter(createI18nApplyOp(op.owner, null), op);
             }
         }
     }
@@ -11033,12 +11114,37 @@ function needsApplication(op) {
         return true;
     }
     // If the next op is an expression targeting a different i18n block, we need to apply.
-    if (op.next.target !== op.target) {
+    if (op.next.owner !== op.owner) {
         return true;
     }
     return false;
 }
 
+/**
+ * Updates i18n expression ops to depend on the last slot in their owning i18n block.
+ */
+function phaseAssignI18nSlotDependencies(job) {
+    const i18nLastSlotConsumers = new Map();
+    let lastSlotConsumer = 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;
+            }
+        }
+        // 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);
+            }
+        }
+    }
+}
+
 /**
  * Gets a map of all elements in the given view by their xref id.
  */
@@ -11793,31 +11899,13 @@ function phaseGenerateAdvance(job) {
     for (const unit of job.units) {
         // First build a map of all of the declarations in the view that have assigned slots.
         const slotMap = new Map();
-        let lastSlotOp = null;
         for (const op of unit.create) {
-            // For i18n blocks, we want to advance to the last element index in the block before invoking
-            // `i18nExp` instructions, to make sure the necessary lifecycle hooks of components/directives
-            // are properly flushed.
-            if (op.kind === OpKind.I18nEnd) {
-                if (lastSlotOp === null) {
-                    throw Error('Expected to have encountered an op prior to i18nEnd that consumes a slot');
-                }
-                // TODO(mmalerba): For empty i18n blocks, we move to the next slot to match
-                // TemplateDefinitionBuilder. This seems like just a quirk resulting from the special
-                // handling of i18n blocks that can be removed when compatibility is no longer required.
-                let lastSlot = lastSlotOp.slot;
-                if (lastSlotOp.kind === OpKind.I18nStart && job.compatibility) {
-                    lastSlot++;
-                }
-                slotMap.set(op.xref, lastSlot);
-            }
             if (!hasConsumesSlotTrait(op)) {
                 continue;
             }
             else if (op.slot === null) {
                 throw new Error(`AssertionError: expected slots to have been allocated before generating advance() calls`);
             }
-            lastSlotOp = op;
             slotMap.set(op.xref, op.slot);
         }
         // Next, step through the update operations and generate `ir.AdvanceOp`s as required to ensure
@@ -11955,7 +12043,6 @@ function getScopeForView(view, parent) {
     }
     for (const op of view.create) {
         switch (op.kind) {
-            case OpKind.Element:
             case OpKind.ElementStart:
             case OpKind.Template:
                 if (!Array.isArray(op.localRefs)) {
@@ -12123,9 +12210,8 @@ function phaseI18nConstCollection(job) {
     // Assign const index to i18n ops that messages were extracted from.
     for (const unit of job.units) {
         for (const op of unit.create) {
-            if ((op.kind === OpKind.I18nStart || op.kind === OpKind.I18n) &&
-                messageConstIndices[op.xref] !== undefined) {
-                op.messageIndex = messageConstIndices[op.xref];
+            if (op.kind === OpKind.I18nStart) {
+                op.messageIndex = messageConstIndices[op.root];
             }
         }
     }
@@ -14421,7 +14507,7 @@ let TAG_DEFINITIONS;
 function getHtmlTagDefinition(tagName) {
     if (!TAG_DEFINITIONS) {
         DEFAULT_TAG_DEFINITION = new HtmlTagDefinition({ canSelfClose: true });
-        TAG_DEFINITIONS = {
+        TAG_DEFINITIONS = Object.assign(Object.create(null), {
             'base': new HtmlTagDefinition({ isVoid: true }),
             'meta': new HtmlTagDefinition({ isVoid: true }),
             'area': new HtmlTagDefinition({ isVoid: true }),
@@ -14483,9 +14569,9 @@ function getHtmlTagDefinition(tagName) {
                 contentType: { default: TagContentType.ESCAPABLE_RAW_TEXT, svg: TagContentType.PARSABLE_DATA }
             }),
             'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
-        };
+        });
         new DomElementSchemaRegistry().allKnownElementNames().forEach(knownTagName => {
-            if (!TAG_DEFINITIONS.hasOwnProperty(knownTagName) && getNsPrefix(knownTagName) === null) {
+            if (!TAG_DEFINITIONS[knownTagName] && getNsPrefix(knownTagName) === null) {
                 TAG_DEFINITIONS[knownTagName] = new HtmlTagDefinition({ canSelfClose: false });
             }
         });
@@ -17078,7 +17164,7 @@ class _Tokenizer {
                 this.handleError(e);
             }
         }
-        this._beginToken(28 /* TokenType.EOF */);
+        this._beginToken(29 /* TokenType.EOF */);
         this._endToken([]);
     }
     _getBlockName() {
@@ -17099,7 +17185,7 @@ class _Tokenizer {
     }
     _consumeBlockStart(start) {
         this._beginToken(24 /* TokenType.BLOCK_OPEN_START */, start);
-        this._endToken([this._getBlockName()]);
+        const startToken = this._endToken([this._getBlockName()]);
         if (this._cursor.peek() === $LPAREN) {
             // Advance past the opening paren.
             this._cursor.advance();
@@ -17107,14 +17193,22 @@ class _Tokenizer {
             this._consumeBlockParameters();
             // Allow spaces before the closing paren.
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            // Skip over the closing paren.
-            this._requireCharCode($RPAREN);
-            // Allow spaces after the paren.
-            this._attemptCharCodeUntilFn(isNotWhitespace);
+            if (this._attemptCharCode($RPAREN)) {
+                // Allow spaces after the paren.
+                this._attemptCharCodeUntilFn(isNotWhitespace);
+            }
+            else {
+                startToken.type = 28 /* TokenType.INCOMPLETE_BLOCK_OPEN */;
+                return;
+            }
+        }
+        if (this._attemptCharCode($LBRACE)) {
+            this._beginToken(25 /* TokenType.BLOCK_OPEN_END */);
+            this._endToken([]);
+        }
+        else {
+            startToken.type = 28 /* TokenType.INCOMPLETE_BLOCK_OPEN */;
         }
-        this._beginToken(25 /* TokenType.BLOCK_OPEN_END */);
-        this._requireCharCode($LBRACE);
-        this._endToken([]);
     }
     _consumeBlockEnd(start) {
         this._beginToken(26 /* TokenType.BLOCK_CLOSE */, start);
@@ -18087,7 +18181,7 @@ class _TreeBuilder {
         this._advance();
     }
     build() {
-        while (this._peek.type !== 28 /* TokenType.EOF */) {
+        while (this._peek.type !== 29 /* TokenType.EOF */) {
             if (this._peek.type === 0 /* TokenType.TAG_OPEN_START */ ||
                 this._peek.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
                 this._consumeStartTag(this._advance());
@@ -18119,6 +18213,10 @@ class _TreeBuilder {
                 this._closeVoidElement();
                 this._consumeBlockClose(this._advance());
             }
+            else if (this._peek.type === 28 /* TokenType.INCOMPLETE_BLOCK_OPEN */) {
+                this._closeVoidElement();
+                this._consumeIncompleteBlock(this._advance());
+            }
             else {
                 // Skip all other tokens...
                 this._advance();
@@ -18192,7 +18290,7 @@ class _TreeBuilder {
         if (!exp)
             return null;
         const end = this._advance();
-        exp.push({ type: 28 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
+        exp.push({ type: 29 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
         // parse everything in between { and }
         const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
         expansionCaseParser.build();
@@ -18232,7 +18330,7 @@ class _TreeBuilder {
                     return null;
                 }
             }
-            if (this._peek.type === 28 /* TokenType.EOF */) {
+            if (this._peek.type === 29 /* TokenType.EOF */) {
                 this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
                 return null;
             }
@@ -18434,17 +18532,31 @@ class _TreeBuilder {
         const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
         const block = new Block(token.parts[0], parameters, [], span, startSpan);
         this._pushContainer(block, false);
-        return block;
     }
     _consumeBlockClose(token) {
-        const previousContainer = this._getContainer();
         if (!this._popContainer(null, Block, token.sourceSpan)) {
-            const context = previousContainer instanceof Element ?
-                `There is an unclosed "${previousContainer.name}" HTML tag that may have to be closed first.` :
-                `The block may have been closed earlier.`;
-            this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. ${context}`));
+            this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. The block may have been closed earlier. ` +
+                `If you meant to write the } character, you should use the "}" ` +
+                `HTML entity instead.`));
         }
     }
+    _consumeIncompleteBlock(token) {
+        const parameters = [];
+        while (this._peek.type === 27 /* TokenType.BLOCK_PARAMETER */) {
+            const paramToken = this._advance();
+            parameters.push(new BlockParameter(paramToken.parts[0], paramToken.sourceSpan));
+        }
+        const end = this._peek.sourceSpan.fullStart;
+        const span = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+        // Create a separate `startSpan` because `span` will be modified when there is an `end` span.
+        const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+        const block = new Block(token.parts[0], parameters, [], span, startSpan);
+        this._pushContainer(block, false);
+        // Incomplete blocks don't have children so we close them immediately and report an error.
+        this._popContainer(null, Block, null);
+        this.errors.push(TreeError.create(token.parts[0], span, `Incomplete block "${token.parts[0]}". If you meant to write the @ character, ` +
+            `you should use the "@" HTML entity instead.`));
+    }
     _getContainer() {
         return this._containerStack.length > 0 ? this._containerStack[this._containerStack.length - 1] :
             null;
@@ -18997,17 +19109,29 @@ function phaseI18nMessageExtraction(job) {
     const fileBasedI18nSuffix = job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_').toUpperCase() + '_';
     for (const unit of job.units) {
         for (const op of unit.create) {
-            if ((op.kind === OpKind.I18nStart || op.kind === OpKind.I18n)) {
-                // Sort the params map to match the ordering in TemplateDefinitionBuilder.
-                const params = new Map([...op.params.entries()].sort());
-                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);
-                // TODO: figure out transformFn.
-                const statements = getTranslationDeclStmts$1(op.message, mainVar, closureVar, params, undefined /*transformFn*/);
-                unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
+            if (op.kind === OpKind.I18nStart) {
+                // Only extract messages from root i18n ops, not sub-template ones.
+                if (op.xref === op.root) {
+                    // Sort the params map to match the ordering in TemplateDefinitionBuilder.
+                    const params = new Map([...op.params.entries()].sort());
+                    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.postprocessingParams.size > 0) {
+                            extraTransformFnParams.push(literalMap([...op.postprocessingParams.entries()].map(([key, value]) => ({ key, value, quoted: true }))));
+                        }
+                        transformFn = (expr) => importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
+                    }
+                    const statements = getTranslationDeclStmts$1(op.message, mainVar, closureVar, params, transformFn);
+                    unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
+                }
             }
         }
     }
@@ -19118,7 +19242,7 @@ function phaseI18nTextExtraction(job) {
                     for (let i = 0; i < op.interpolation.expressions.length; i++) {
                         const expr = op.interpolation.expressions[i];
                         const placeholder = op.i18nPlaceholders[i];
-                        ops.push(createI18nExpressionOp(i18nBlockId, expr, placeholder, expr.sourceSpan ?? op.sourceSpan));
+                        ops.push(createI18nExpressionOp(i18nBlockId, expr, placeholder.name, I18nParamResolutionTime.Creation, expr.sourceSpan ?? op.sourceSpan));
                     }
                     if (ops.length > 0) {
                         // ops.push(ir.createI18nApplyOp(i18nBlockId, op.i18nPlaceholders, op.sourceSpan));
@@ -19130,6 +19254,50 @@ function phaseI18nTextExtraction(job) {
     }
 }
 
+/**
+ * Extracts ICUs into i18n expressions.
+ */
+function phaseIcuExtraction(job) {
+    for (const unit of job.units) {
+        // Build a map of ICU to the i18n block they belong to, then remove the `Icu` ops.
+        const icus = new Map();
+        let currentI18nId = null;
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    currentI18nId = op.xref;
+                    break;
+                case OpKind.I18nEnd:
+                    currentI18nId = null;
+                    break;
+                case OpKind.Icu:
+                    if (currentI18nId === null) {
+                        throw Error('Unexpected ICU outside of an i18n block.');
+                    }
+                    icus.set(op.xref, { message: op.message, i18nBlockId: currentI18nId });
+                    OpList.remove(op);
+                    break;
+            }
+        }
+        // Replace the `IcuUpdate` ops with `i18nExpr` ops.
+        for (const op of unit.update) {
+            switch (op.kind) {
+                case OpKind.IcuUpdate:
+                    const { message, i18nBlockId } = icus.get(op.xref);
+                    const icuNode = message.nodes.find((n) => n instanceof Icu);
+                    if (icuNode === undefined) {
+                        throw Error('Could not find ICU in i18n AST');
+                    }
+                    if (icuNode.expressionPlaceholder === undefined) {
+                        throw Error('ICU is missing an i18n placeholder');
+                    }
+                    OpList.replace(op, createI18nExpressionOp(i18nBlockId, new LexicalReadExpr(icuNode.expression), icuNode.expressionPlaceholder, I18nParamResolutionTime.Postproccessing, null));
+                    break;
+            }
+        }
+    }
+}
+
 /**
  * Lifts local reference declarations on element-like structures within each view into an entry in
  * the `consts` array for the whole component.
@@ -19139,7 +19307,6 @@ function phaseLocalRefs(job) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.ElementStart:
-                case OpKind.Element:
                 case OpKind.Template:
                     if (!Array.isArray(op.localRefs)) {
                         throw new Error(`AssertionError: expected localRefs to be an array still`);
@@ -19172,7 +19339,7 @@ function phaseNamespace(job) {
     for (const unit of job.units) {
         let activeNamespace = Namespace.HTML;
         for (const op of unit.create) {
-            if (op.kind !== OpKind.Element && op.kind !== OpKind.ElementStart) {
+            if (op.kind !== OpKind.ElementStart) {
                 continue;
             }
             if (op.namespace !== activeNamespace) {
@@ -19317,7 +19484,8 @@ function addNamesToView(unit, baseName, state, compatibility) {
                 if (op.slot === null) {
                     throw new Error(`Expected slot to be assigned`);
                 }
-                addNamesToView(childView, `${baseName}_${prefixWithNamespace(op.tag, op.namespace)}_${op.slot}`, state, compatibility);
+                const tagToken = op.tag === null ? '' : '_' + prefixWithNamespace(op.tag, op.namespace);
+                addNamesToView(childView, `${baseName}${tagToken}_${op.slot}`, state, compatibility);
                 break;
             case OpKind.StyleProp:
                 op.name = normalizeStylePropName(op.name);
@@ -19451,11 +19619,6 @@ function phaseNgContainer(job) {
     for (const unit of job.units) {
         const updatedElementXrefs = new Set();
         for (const op of unit.create) {
-            if (op.kind === OpKind.Element && op.tag === CONTAINER_TAG) {
-                // Transmute the `Element` instruction to `Container`.
-                op.kind = OpKind.Container;
-                updatedElementXrefs.add(op.xref);
-            }
             if (op.kind === OpKind.ElementStart && op.tag === CONTAINER_TAG) {
                 // Transmute the `ElementStart` instruction to `ContainerStart`.
                 op.kind = OpKind.ContainerStart;
@@ -19739,6 +19902,55 @@ function phasePipeVariadic(job) {
     }
 }
 
+/**
+ * Propagate i18n blocks down through child templates that act as placeholders in the root i18n
+ * message.
+ */
+function phasePropagateI18nBlocks(job) {
+    propagateI18nBlocksToTemplates(job.root, 0);
+}
+/**
+ * Propagates i18n ops in the given view through to any child views recursively.
+ */
+function propagateI18nBlocksToTemplates(unit, subTemplateIndex) {
+    let i18nBlock = null;
+    for (const op of unit.create) {
+        switch (op.kind) {
+            case OpKind.I18nStart:
+                op.subTemplateIndex = subTemplateIndex === 0 ? null : subTemplateIndex;
+                i18nBlock = op;
+                break;
+            case OpKind.I18nEnd:
+                i18nBlock = null;
+                break;
+            case OpKind.Template:
+                const templateView = unit.job.views.get(op.xref);
+                // We found an <ng-template> inside an i18n block; increment the sub-template counter and
+                // wrap the template's view in a child i18n block.
+                if (op.i18nPlaceholder !== undefined) {
+                    if (i18nBlock === null) {
+                        throw Error('Expected template with i18n placeholder to be in an i18n block.');
+                    }
+                    subTemplateIndex++;
+                    wrapTemplateWithI18n(templateView, i18nBlock);
+                }
+                // Continue traversing inside the template's view.
+                propagateI18nBlocksToTemplates(templateView, subTemplateIndex);
+        }
+    }
+}
+/**
+ * Wraps a template view with i18n start and end ops.
+ */
+function wrapTemplateWithI18n(unit, parentI18n) {
+    // Only add i18n ops if they have not already been propagated to this template.
+    if (unit.create.head.next?.kind !== OpKind.I18nStart) {
+        const id = unit.job.allocateXrefId();
+        OpList.insertAfter(createI18nStartOp(id, parentI18n.message, parentI18n.root), unit.create.head);
+        OpList.insertBefore(createI18nEndOp(id), unit.create.tail);
+    }
+}
+
 function phasePureFunctionExtraction(job) {
     for (const view of job.units) {
         for (const op of view.ops()) {
@@ -19869,7 +20081,7 @@ function elementContainerEnd() {
 }
 function template(slot, templateFnRef, decls, vars, tag, constIndex, sourceSpan) {
     const args = [literal(slot), templateFnRef, literal(decls), literal(vars)];
-    if (tag !== null) {
+    if (tag !== null || constIndex !== null) {
         args.push(literal(tag));
         if (constIndex !== null) {
             args.push(literal(constIndex));
@@ -19975,11 +20187,19 @@ function projection(slot, projectionSlotIndex, attributes) {
     }
     return call(Identifiers.projection, args, null);
 }
-function i18nStart(slot, constIndex) {
-    return call(Identifiers.i18nStart, [literal(slot), literal(constIndex)], null);
+function i18nStart(slot, constIndex, subTemplateIndex) {
+    const args = [literal(slot), literal(constIndex)];
+    if (subTemplateIndex !== null) {
+        args.push(literal(subTemplateIndex));
+    }
+    return call(Identifiers.i18nStart, args, null);
 }
-function i18n(slot, constIndex) {
-    return call(Identifiers.i18n, [literal(slot), literal(constIndex)], null);
+function i18n(slot, constIndex, subTemplateIndex) {
+    const args = [literal(slot), literal(constIndex)];
+    if (subTemplateIndex) {
+        args.push(literal(subTemplateIndex));
+    }
+    return call(Identifiers.i18n, args, null);
 }
 function i18nEnd() {
     return call(Identifiers.i18nEnd, [], null);
@@ -20362,13 +20582,13 @@ function reifyCreateOperations(unit, ops) {
                 OpList.replace(op, elementContainerEnd());
                 break;
             case OpKind.I18nStart:
-                OpList.replace(op, i18nStart(op.slot, op.messageIndex));
+                OpList.replace(op, i18nStart(op.slot, op.messageIndex, op.subTemplateIndex));
                 break;
             case OpKind.I18nEnd:
                 OpList.replace(op, i18nEnd());
                 break;
             case OpKind.I18n:
-                OpList.replace(op, i18n(op.slot, op.messageIndex));
+                OpList.replace(op, i18n(op.slot, op.messageIndex, op.subTemplateIndex));
                 break;
             case OpKind.Template:
                 if (!(unit instanceof ViewCompilationUnit)) {
@@ -20706,96 +20926,279 @@ function resolveDollarEvent(unit, ops) {
  * The escape sequence used indicate message param values.
  */
 const ESCAPE = '\uFFFD';
+/**
+ * Marker used to indicate an element tag.
+ */
+const ELEMENT_MARKER = '#';
+/**
+ * Marker used to indicate a template tag.
+ */
+const TEMPLATE_MARKER = '*';
+/**
+ * Marker used to indicate closing of an element or template tag.
+ */
+const TAG_CLOSE_MARKER = '/';
+/**
+ * Marker used to indicate the sub-template context.
+ */
+const CONTEXT_MARKER = ':';
+/**
+ * Marker used to indicate the start of a list of values.
+ */
+const LIST_START_MARKER = '[';
+/**
+ * Marker used to indicate the end of a list of values.
+ */
+const LIST_END_MARKER = ']';
+/**
+ * Delimiter used to separate multiple values in a list.
+ */
+const LIST_DELIMITER = '|';
+/**
+ * Flags that describe what an i18n param value. These determine how the value is serialized into
+ * the final map.
+ */
+var I18nParamValueFlags;
+(function (I18nParamValueFlags) {
+    I18nParamValueFlags[I18nParamValueFlags["None"] = 0] = "None";
+    /**
+     *  This value represtents an element tag.
+     */
+    I18nParamValueFlags[I18nParamValueFlags["ElementTag"] = 1] = "ElementTag";
+    /**
+     * This value represents a template tag.
+     */
+    I18nParamValueFlags[I18nParamValueFlags["TemplateTag"] = 2] = "TemplateTag";
+    /**
+     * This value represents the opening of a tag.
+     */
+    I18nParamValueFlags[I18nParamValueFlags["OpenTag"] = 4] = "OpenTag";
+    /**
+     * This value represents the closing of a tag.
+     */
+    I18nParamValueFlags[I18nParamValueFlags["CloseTag"] = 8] = "CloseTag";
+})(I18nParamValueFlags || (I18nParamValueFlags = {}));
+/**
+ * Represents the complete i18n params map for an i18n op.
+ */
+class I18nPlaceholderParams {
+    constructor() {
+        this.values = new Map();
+    }
+    /**
+     * Adds a new value to the params map.
+     */
+    addValue(placeholder, value, subTemplateIndex, resolutionTime, flags) {
+        const placeholderValues = this.values.get(placeholder) ?? [];
+        placeholderValues.push({ value, subTemplateIndex, resolutionTime, flags });
+        this.values.set(placeholder, placeholderValues);
+    }
+    /**
+     * Saves the params map, in serialized form, into the given i18n op.
+     */
+    saveToOp(op) {
+        for (const [placeholder, placeholderValues] of this.values) {
+            // We need to run post-processing for any 1i8n ops that contain parameters with more than
+            // one value, even if there are no parameters resolved at post-processing time.
+            const creationValues = placeholderValues.filter(({ resolutionTime }) => resolutionTime === I18nParamResolutionTime.Creation);
+            if (creationValues.length > 1) {
+                op.needsPostprocessing = true;
+            }
+            // Save creation time params to op.
+            const serializedCreationValues = this.serializeValues(creationValues);
+            if (serializedCreationValues !== null) {
+                op.params.set(placeholder, literal(serializedCreationValues));
+            }
+            // Save post-processing time params to op.
+            const serializedPostprocessingValues = this.serializeValues(placeholderValues.filter(({ resolutionTime }) => resolutionTime === I18nParamResolutionTime.Postproccessing));
+            if (serializedPostprocessingValues !== null) {
+                op.needsPostprocessing = true;
+                op.postprocessingParams.set(placeholder, literal(serializedPostprocessingValues));
+            }
+        }
+    }
+    /**
+     * Merges another param map into this one.
+     */
+    merge(other) {
+        for (const [placeholder, otherValues] of other.values) {
+            const currentValues = this.values.get(placeholder) || [];
+            // Child element close tag params should be prepended to maintain the same order as
+            // TemplateDefinitionBuilder.
+            const flags = otherValues[0].flags;
+            if ((flags & I18nParamValueFlags.CloseTag) && !(flags & I18nParamValueFlags.OpenTag)) {
+                this.values.set(placeholder, [...otherValues, ...currentValues]);
+            }
+            else {
+                this.values.set(placeholder, [...currentValues, ...otherValues]);
+            }
+        }
+    }
+    /**
+     * Serializes a list of i18n placeholder values.
+     */
+    serializeValues(values) {
+        if (values.length === 0) {
+            return null;
+        }
+        const serializedValues = values.map(value => this.serializeValue(value));
+        return serializedValues.length === 1 ?
+            serializedValues[0] :
+            `${LIST_START_MARKER}${serializedValues.join(LIST_DELIMITER)}${LIST_END_MARKER}`;
+    }
+    /**
+     * Serializes a single i18n placeholder value.
+     */
+    serializeValue(value) {
+        let tagMarker = '';
+        let closeMarker = '';
+        if (value.flags & I18nParamValueFlags.ElementTag) {
+            tagMarker = ELEMENT_MARKER;
+        }
+        else if (value.flags & I18nParamValueFlags.TemplateTag) {
+            tagMarker = TEMPLATE_MARKER;
+        }
+        if (tagMarker !== '') {
+            closeMarker = value.flags & I18nParamValueFlags.CloseTag ? TAG_CLOSE_MARKER : '';
+        }
+        const context = value.subTemplateIndex === null ? '' : `${CONTEXT_MARKER}${value.subTemplateIndex}`;
+        // Self-closing tags use a special form that concatenates the start and close tag values.
+        if ((value.flags & I18nParamValueFlags.OpenTag) &&
+            (value.flags & I18nParamValueFlags.CloseTag)) {
+            return `${ESCAPE}${tagMarker}${value.value}${context}${ESCAPE}${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+        }
+        return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+    }
+}
 /**
  * Resolve the placeholders in i18n messages.
  */
 function phaseResolveI18nPlaceholders(job) {
+    const params = new Map();
+    const i18nOps = new Map();
+    resolvePlaceholders(job, params, i18nOps);
+    propagatePlaceholders(params, i18nOps);
+    // After colleccting all params, save them to the i18n ops.
+    for (const [xref, i18nOpParams] of params) {
+        i18nOpParams.saveToOp(i18nOps.get(xref));
+    }
+    // Validate the root i18n ops have all placeholders filled in.
+    for (const op of i18nOps.values()) {
+        if (op.xref === op.root) {
+            for (const placeholder in op.message.placeholders) {
+                if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
+                    throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Resolve placeholders for each i18n op.
+ */
+function resolvePlaceholders(job, params, i18nOps) {
     for (const unit of job.units) {
-        const i18nOps = new Map();
-        let startTagSlots = new Map();
-        let closeTagSlots = new Map();
+        const elements = new Map();
         let currentI18nOp = null;
         // Record slots for tag name placeholders.
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
-                case OpKind.I18n:
-                    // Initialize collected slots for a new i18n block.
                     i18nOps.set(op.xref, op);
                     currentI18nOp = op.kind === OpKind.I18nStart ? op : null;
-                    startTagSlots = new Map();
-                    closeTagSlots = new Map();
                     break;
                 case OpKind.I18nEnd:
-                    // Add values for tag placeholders.
-                    if (currentI18nOp === null) {
-                        throw Error('Missing corresponding i18n start op for i18n end op');
-                    }
-                    for (const [placeholder, slots] of startTagSlots) {
-                        currentI18nOp.params.set(placeholder, serializeSlots(slots, true));
-                    }
-                    for (const [placeholder, slots] of closeTagSlots) {
-                        currentI18nOp.params.set(placeholder, serializeSlots(slots, false));
-                    }
                     currentI18nOp = null;
                     break;
-                case OpKind.Element:
                 case OpKind.ElementStart:
-                    // Record slots for tag placeholders.
-                    if (op.i18nPlaceholder != undefined) {
+                    // For elements with i18n placeholders, record its slot value in the params map under the
+                    // corresponding tag start placeholder.
+                    if (op.i18nPlaceholder !== undefined) {
                         if (currentI18nOp === null) {
                             throw Error('i18n tag placeholder should only occur inside an i18n block');
                         }
-                        if (!op.slot) {
-                            throw Error('Slots should be allocated before i18n placeholder resolution');
-                        }
+                        elements.set(op.xref, op);
                         const { startName, closeName } = op.i18nPlaceholder;
-                        addTagSlot(startTagSlots, startName, op.slot);
-                        addTagSlot(closeTagSlots, closeName, op.slot);
+                        let flags = I18nParamValueFlags.ElementTag | I18nParamValueFlags.OpenTag;
+                        // For self-closing tags, there is no close tag placeholder. Instead, the start tag
+                        // placeholder accounts for the start and close of the element.
+                        if (closeName === '') {
+                            flags |= I18nParamValueFlags.CloseTag;
+                        }
+                        addParam(params, currentI18nOp, startName, op.slot, currentI18nOp.subTemplateIndex, I18nParamResolutionTime.Creation, flags);
+                    }
+                    break;
+                case OpKind.ElementEnd:
+                    const startOp = elements.get(op.xref);
+                    if (startOp && startOp.i18nPlaceholder !== undefined) {
+                        if (currentI18nOp === null) {
+                            throw Error('i18n tag placeholder should only occur inside an i18n block');
+                        }
+                        const { closeName } = startOp.i18nPlaceholder;
+                        // Self-closing tags don't have a closing tag placeholder.
+                        if (closeName !== '') {
+                            addParam(params, currentI18nOp, closeName, startOp.slot, currentI18nOp.subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.ElementTag | I18nParamValueFlags.CloseTag);
+                        }
+                    }
+                    break;
+                case OpKind.Template:
+                    if (op.i18nPlaceholder !== undefined) {
+                        if (currentI18nOp === null) {
+                            throw Error('i18n tag placeholder should only occur inside an i18n block');
+                        }
+                        const subTemplateIndex = getSubTemplateIndexForTemplateTag(job, currentI18nOp, op);
+                        addParam(params, currentI18nOp, op.i18nPlaceholder.startName, op.slot, subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.TemplateTag);
+                        addParam(params, currentI18nOp, op.i18nPlaceholder.closeName, op.slot, subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.TemplateTag | I18nParamValueFlags.CloseTag);
                     }
                     break;
             }
         }
-        // Fill in values for each of the expression placeholders applied in i18nApply operations.
+        // Fill in values for each of the i18n expression placeholders.
         const i18nBlockPlaceholderIndices = new Map();
         for (const op of unit.update) {
             if (op.kind === OpKind.I18nExpression) {
-                const i18nOp = i18nOps.get(op.target);
-                let index = i18nBlockPlaceholderIndices.get(op.target) || 0;
+                const i18nOp = i18nOps.get(op.owner);
+                let index = i18nBlockPlaceholderIndices.get(op.owner) || 0;
                 if (!i18nOp) {
                     throw Error('Cannot find corresponding i18nStart for i18nExpr');
                 }
-                i18nOp.params.set(op.i18nPlaceholder.name, literal(`${ESCAPE}${index++}${ESCAPE}`));
-                i18nBlockPlaceholderIndices.set(op.target, index);
-            }
-        }
-        // Verify that all placeholders have been resolved.
-        for (const op of i18nOps.values()) {
-            for (const placeholder in op.message.placeholders) {
-                if (!op.params.has(placeholder)) {
-                    throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
-                }
+                addParam(params, i18nOp, op.i18nPlaceholder, index++, i18nOp.subTemplateIndex, op.resolutionTime);
+                i18nBlockPlaceholderIndices.set(op.owner, index);
             }
         }
     }
 }
 /**
- * Updates the given slots map with the specified slot.
+ * Add a param to the params map for the given i18n op.
  */
-function addTagSlot(tagSlots, placeholder, slot) {
-    const slots = tagSlots.get(placeholder) || [];
-    slots.push(slot);
-    tagSlots.set(placeholder, slots);
+function addParam(params, i18nOp, placeholder, value, subTemplateIndex, resolutionTime, flags = I18nParamValueFlags.None) {
+    const i18nOpParams = params.get(i18nOp.xref) || new I18nPlaceholderParams();
+    i18nOpParams.addValue(placeholder, value, subTemplateIndex, resolutionTime, flags);
+    params.set(i18nOp.xref, i18nOpParams);
+}
+/**
+ * Get the subTemplateIndex for the given template op. For template ops, use the subTemplateIndex of
+ * the child i18n block inside the template.
+ */
+function getSubTemplateIndexForTemplateTag(job, i18nOp, op) {
+    for (const childOp of job.views.get(op.xref).create) {
+        if (childOp.kind === OpKind.I18nStart) {
+            return childOp.subTemplateIndex;
+        }
+    }
+    return i18nOp.subTemplateIndex;
 }
 /**
- * Serializes a list of slots to a string literal expression.
+ * Propagate placeholders up to their root i18n op.
  */
-function serializeSlots(slots, start) {
-    const slotStrings = slots.map(slot => `${ESCAPE}${start ? '' : '/'}#${slot}${ESCAPE}`);
-    if (slotStrings.length === 1) {
-        return literal(slotStrings[0]);
+function propagatePlaceholders(params, i18nOps) {
+    for (const [xref, opParams] of params) {
+        const op = i18nOps.get(xref);
+        if (op.xref !== op.root) {
+            const rootParams = params.get(op.root) || new I18nPlaceholderParams();
+            rootParams.merge(opParams);
+        }
     }
-    return literal(`[${slotStrings.join('|')}]`);
 }
 
 /**
@@ -20938,8 +21341,7 @@ function phaseResolveSanitizers(job) {
  * Checks whether the given op represents an iframe element.
  */
 function isIframeElement$1(op) {
-    return (op.kind === OpKind.Element || op.kind === OpKind.ElementStart) &&
-        op.tag.toLowerCase() === 'iframe';
+    return op.kind === OpKind.ElementStart && op.tag?.toLowerCase() === 'iframe';
 }
 
 function phaseSaveRestoreView(job) {
@@ -21553,18 +21955,47 @@ function allowConservativeInlining(decl, target) {
     }
 }
 
+/**
+ * Wraps ICUs that do not already belong to an i18n block in a new i18n block.
+ */
+function phaseWrapIcus(job) {
+    for (const unit of job.units) {
+        let currentI18nOp = null;
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    currentI18nOp = op;
+                    break;
+                case OpKind.I18nEnd:
+                    currentI18nOp = null;
+                    break;
+                case OpKind.Icu:
+                    if (currentI18nOp === null) {
+                        const id = job.allocateXrefId();
+                        OpList.insertBefore(createI18nStartOp(id, op.message), op);
+                        OpList.insertAfter(createI18nEndOp(id), op);
+                    }
+                    break;
+            }
+        }
+    }
+}
+
 const phases = [
     { kind: CompilationJobKind.Tmpl, fn: phaseRemoveContentSelectors },
     { kind: CompilationJobKind.Host, fn: phaseHostStylePropertyParsing },
     { kind: CompilationJobKind.Tmpl, fn: phaseNamespace },
     { kind: CompilationJobKind.Both, fn: phaseStyleBindingSpecialization },
     { kind: CompilationJobKind.Both, fn: phaseBindingSpecialization },
+    { kind: CompilationJobKind.Tmpl, fn: phasePropagateI18nBlocks },
+    { kind: CompilationJobKind.Tmpl, fn: phaseWrapIcus },
     { kind: CompilationJobKind.Both, fn: phaseAttributeExtraction },
     { kind: CompilationJobKind.Both, fn: phaseParseExtractedStyles },
     { kind: CompilationJobKind.Tmpl, fn: phaseRemoveEmptyBindings },
     { kind: CompilationJobKind.Tmpl, fn: phaseConditionals },
     { kind: CompilationJobKind.Tmpl, fn: phasePipeCreation },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nTextExtraction },
+    { kind: CompilationJobKind.Tmpl, fn: phaseIcuExtraction },
     { kind: CompilationJobKind.Tmpl, fn: phaseApplyI18nExpressions },
     { kind: CompilationJobKind.Tmpl, fn: phasePipeVariadic },
     { kind: CompilationJobKind.Both, fn: phasePureLiteralStructures },
@@ -21586,6 +22017,7 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nConstCollection },
     { kind: CompilationJobKind.Tmpl, fn: phaseConstTraitCollection },
     { kind: CompilationJobKind.Both, fn: phaseConstCollection },
+    { kind: CompilationJobKind.Tmpl, fn: phaseAssignI18nSlotDependencies },
     { kind: CompilationJobKind.Both, fn: phaseVarCounting },
     { kind: CompilationJobKind.Tmpl, fn: phaseGenerateAdvance },
     { kind: CompilationJobKind.Both, fn: phaseVariableOptimization },
@@ -21798,6 +22230,9 @@ function ingestNodes(unit, template) {
         else if (node instanceof DeferredBlock) {
             ingestDeferBlock(unit, node);
         }
+        else if (node instanceof Icu$1) {
+            ingestIcu(unit, node);
+        }
         else {
             throw new Error(`Unsupported template node: ${node.constructor.name}`);
         }
@@ -21835,7 +22270,8 @@ function ingestElement(unit, element) {
  * Ingest an `ng-template` node from the AST into the given `ViewCompilation`.
  */
 function ingestTemplate(unit, tmpl) {
-    if (tmpl.i18n !== undefined && !(tmpl.i18n instanceof Message)) {
+    if (tmpl.i18n !== undefined &&
+        !(tmpl.i18n instanceof Message || tmpl.i18n instanceof TagPlaceholder)) {
         throw Error(`Unhandled i18n metadata type for template: ${tmpl.i18n.constructor.name}`);
     }
     const childView = unit.job.allocateView(unit.xref);
@@ -21844,8 +22280,8 @@ function ingestTemplate(unit, tmpl) {
     if (tmpl.tagName) {
         [namespacePrefix, tagNameWithoutNamespace] = splitNsName(tmpl.tagName);
     }
-    // TODO: validate the fallback tag name here.
-    const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace ?? 'ng-template', namespaceForKey(namespacePrefix), false, undefined, tmpl.startSourceSpan);
+    const i18nPlaceholder = tmpl.i18n instanceof TagPlaceholder ? tmpl.i18n : undefined;
+    const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace, namespaceForKey(namespacePrefix), false, i18nPlaceholder, tmpl.startSourceSpan);
     unit.create.push(tplOp);
     ingestBindings(unit, tplOp, tmpl);
     ingestReferences(tplOp, tmpl);
@@ -21853,8 +22289,10 @@ function ingestTemplate(unit, tmpl) {
     for (const { name, value } of tmpl.variables) {
         childView.contextVariables.set(name, value);
     }
-    // If there is an i18n message associated with this template, insert i18n start and end ops.
-    if (tmpl.i18n instanceof Message) {
+    // If this is a plain template and there is an i18n message associated with it, insert i18n start
+    // and end ops. For structural directive templates, the i18n ops will be added when ingesting the
+    // element/template the directive is placed on.
+    if (isPlainTemplate(tmpl) && tmpl.i18n instanceof Message) {
         const id = unit.job.allocateXrefId();
         OpList.insertAfter(createI18nStartOp(id, tmpl.i18n), childView.create.head);
         OpList.insertBefore(createI18nEndOp(id), childView.create.tail);
@@ -21888,7 +22326,7 @@ function ingestBoundText(unit, text) {
         throw new Error(`AssertionError: expected Interpolation for BoundText node, got ${value.constructor.name}`);
     }
     if (text.i18n !== undefined && !(text.i18n instanceof Container)) {
-        throw Error(`Unhandled i18n metadata type for text interpolation: ${text.i18n.constructor.name}`);
+        throw Error(`Unhandled i18n metadata type for text interpolation: ${text.i18n?.constructor.name}`);
     }
     const i18nPlaceholders = text.i18n instanceof Container ?
         text.i18n.children.filter((node) => node instanceof Placeholder) :
@@ -21915,7 +22353,7 @@ function ingestIfBlock(unit, ifBlock) {
         if (firstXref === null) {
             firstXref = cView.xref;
         }
-        unit.create.push(createTemplateOp(cView.xref, 'Conditional', Namespace.HTML, true, undefined, ifCase.sourceSpan));
+        unit.create.push(createTemplateOp(cView.xref, 'Conditional', Namespace.HTML, true, undefined /* TODO: figure out how i18n works with new control flow */, ifCase.sourceSpan));
         const caseExpr = ifCase.expression ? convertAst(ifCase.expression, unit.job, null) : null;
         const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, cView.xref, ifCase.expressionAlias);
         conditions.push(conditionalCaseExpr);
@@ -21935,7 +22373,7 @@ function ingestSwitchBlock(unit, switchBlock) {
         if (firstXref === null) {
             firstXref = cView.xref;
         }
-        unit.create.push(createTemplateOp(cView.xref, 'Case', Namespace.HTML, true, undefined, switchCase.sourceSpan));
+        unit.create.push(createTemplateOp(cView.xref, 'Case', Namespace.HTML, true, undefined /* TODO: figure out how i18n works with new control flow */, switchCase.sourceSpan));
         const caseExpr = switchCase.expression ?
             convertAst(switchCase.expression, unit.job, switchBlock.startSourceSpan) :
             null;
@@ -21990,6 +22428,16 @@ function ingestDeferBlock(unit, deferBlock) {
     // Add all ops to the view.
     unit.create.push(deferOnOp);
 }
+function ingestIcu(unit, icu) {
+    if (icu.i18n instanceof Message) {
+        const xref = unit.job.allocateXrefId();
+        unit.create.push(createIcuOp(xref, icu.i18n, null));
+        unit.update.push(createIcuUpdateOp(xref, null));
+    }
+    else {
+        throw Error(`Unhandled i18n metadata type for ICU: ${icu.i18n?.constructor.name}`);
+    }
+}
 /**
  * Convert a template AST expression into an output AST expression.
  */
@@ -22083,16 +22531,35 @@ function convertAst(ast, job, baseSourceSpan) {
         throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
     }
 }
+/**
+ * Checks whether the given template is a plain ng-template (as opposed to another kind of template
+ * such as a structural directive template or control flow template). This is checked based on the
+ * tagName. We can expect that only plain ng-templates will come through with a tagName of
+ * 'ng-template'.
+ *
+ * Here are some of the cases we expect:
+ *
+ * | Angular HTML                       | Template tagName   |
+ * | ---------------------------------- | ------------------ |
+ * | `<ng-template>`                    | 'ng-template'      |
+ * | `<div *ngIf="true">`               | 'div'              |
+ * | `<svg><ng-template>`               | 'svg:ng-template'  |
+ * | `@if (true) {`                     | 'Conditional'      |
+ * | `<ng-template *ngIf>` (plain)      | 'ng-template'      |
+ * | `<ng-template *ngIf>` (structural) | null               |
+ */
+function isPlainTemplate(tmpl) {
+    return splitNsName(tmpl.tagName ?? '')[1] === 'ng-template';
+}
 /**
  * Process all of the bindings on an element-like structure in the template AST and convert them
  * to their IR representation.
  */
 function ingestBindings(unit, op, element) {
     let flags = BindingFlags.None;
-    const isPlainTemplate = element instanceof Template && splitNsName(element.tagName ?? '')[1] === 'ng-template';
     if (element instanceof Template) {
         flags |= BindingFlags.OnNgTemplateElement;
-        if (isPlainTemplate) {
+        if (element instanceof Template && isPlainTemplate(element)) {
             flags |= BindingFlags.BindingTargetsTemplate;
         }
         const templateAttrFlags = flags | BindingFlags.BindingTargetsTemplate | BindingFlags.IsStructuralTemplateAttribute;
@@ -22121,7 +22588,7 @@ function ingestBindings(unit, op, element) {
                 throw Error('Animation listener should have a phase');
             }
         }
-        if (element instanceof Template && !isPlainTemplate) {
+        if (element instanceof Template && !isPlainTemplate(element)) {
             unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, output.name, null));
             continue;
         }
@@ -23385,13 +23852,13 @@ function normalizeNgContentSelect(selectAttr) {
 /** Pattern for the expression in a for loop block. */
 const FOR_LOOP_EXPRESSION_PATTERN = /^\s*([0-9A-Za-z_$]*)\s+of\s+(.*)/;
 /** Pattern for the tracking expression in a for loop block. */
-const FOR_LOOP_TRACK_PATTERN = /^track\s+(.*)/;
+const FOR_LOOP_TRACK_PATTERN = /^track\s+([\S\s]*)/;
 /** Pattern for the `as` expression in a conditional block. */
 const CONDITIONAL_ALIAS_PATTERN = /^as\s+(.*)/;
 /** Pattern used to identify an `else if` block. */
 const ELSE_IF_PATTERN = /^else[^\S\r\n]+if/;
 /** Pattern used to identify a `let` parameter. */
-const FOR_LOOP_LET_PATTERN = /^let\s+(.*)/;
+const FOR_LOOP_LET_PATTERN = /^let\s+([\S\s]*)/;
 /** Names of variables that are allowed to be used in the `let` expression of a `for` loop. */
 const ALLOWED_FOR_LOOP_LET_VARIABLES = new Set(['$index', '$first', '$last', '$even', '$odd', '$count']);
 /**
@@ -23412,28 +23879,33 @@ function isConnectedIfLoopBlock(name) {
 function createIfBlock(ast, connectedBlocks, visitor, bindingParser) {
     const errors = validateIfConnectedBlocks(connectedBlocks);
     const branches = [];
-    if (errors.length > 0) {
-        return { node: null, errors };
-    }
     const mainBlockParams = parseConditionalBlockParameters(ast, errors, bindingParser);
     if (mainBlockParams !== null) {
-        branches.push(new IfBlockBranch(mainBlockParams.expression, visitAll(visitor, ast.children, ast.children), mainBlockParams.expressionAlias, ast.sourceSpan, ast.startSourceSpan));
+        branches.push(new IfBlockBranch(mainBlockParams.expression, visitAll(visitor, ast.children, ast.children), mainBlockParams.expressionAlias, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan));
     }
-    // Assumes that the structure is valid since we validated it above.
     for (const block of connectedBlocks) {
-        const children = visitAll(visitor, block.children, block.children);
         if (ELSE_IF_PATTERN.test(block.name)) {
             const params = parseConditionalBlockParameters(block, errors, bindingParser);
             if (params !== null) {
-                branches.push(new IfBlockBranch(params.expression, children, params.expressionAlias, block.sourceSpan, block.startSourceSpan));
+                const children = visitAll(visitor, block.children, block.children);
+                branches.push(new IfBlockBranch(params.expression, children, params.expressionAlias, block.sourceSpan, block.startSourceSpan, block.endSourceSpan));
             }
         }
         else if (block.name === 'else') {
-            branches.push(new IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan));
+            const children = visitAll(visitor, block.children, block.children);
+            branches.push(new IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan, block.endSourceSpan));
         }
     }
+    // The outer IfBlock should have a span that encapsulates all branches.
+    const ifBlockStartSourceSpan = branches.length > 0 ? branches[0].startSourceSpan : ast.startSourceSpan;
+    const ifBlockEndSourceSpan = branches.length > 0 ? branches[branches.length - 1].endSourceSpan : ast.endSourceSpan;
+    let wholeSourceSpan = ast.sourceSpan;
+    const lastBranch = branches[branches.length - 1];
+    if (lastBranch !== undefined) {
+        wholeSourceSpan = new ParseSourceSpan(ifBlockStartSourceSpan.start, lastBranch.sourceSpan.end);
+    }
     return {
-        node: new IfBlock(branches, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+        node: new IfBlock(branches, wholeSourceSpan, ast.startSourceSpan, ifBlockEndSourceSpan),
         errors,
     };
 }
@@ -23452,7 +23924,7 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
                 errors.push(new ParseError(block.sourceSpan, '@empty block cannot have parameters'));
             }
             else {
-                empty = new ForLoopBlockEmpty(visitAll(visitor, block.children, block.children), block.sourceSpan, block.startSourceSpan);
+                empty = new ForLoopBlockEmpty(visitAll(visitor, block.children, block.children), block.sourceSpan, block.startSourceSpan, block.endSourceSpan);
             }
         }
         else {
@@ -23461,10 +23933,16 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
     }
     if (params !== null) {
         if (params.trackBy === null) {
+            // TODO: We should not fail here, and instead try to produce some AST for the language
+            // service.
             errors.push(new ParseError(ast.sourceSpan, '@for loop must have a "track" expression'));
         }
         else {
-            node = new ForLoopBlock(params.itemName, params.expression, params.trackBy, params.context, visitAll(visitor, ast.children, ast.children), empty, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+            // The `for` block has a main span that includes the `empty` branch. For only the span of the
+            // main `for` body, use `mainSourceSpan`.
+            const endSpan = empty?.endSourceSpan ?? ast.endSourceSpan;
+            const sourceSpan = new ParseSourceSpan(ast.sourceSpan.start, endSpan?.end ?? ast.sourceSpan.end);
+            node = new ForLoopBlock(params.itemName, params.expression, params.trackBy, params.context, visitAll(visitor, ast.children, ast.children), empty, sourceSpan, ast.sourceSpan, ast.startSourceSpan, endSpan);
         }
     }
     return { node, errors };
@@ -23472,21 +23950,25 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
 /** Creates a switch block from an HTML AST node. */
 function createSwitchBlock(ast, visitor, bindingParser) {
     const errors = validateSwitchBlock(ast);
-    if (errors.length > 0) {
-        return { node: null, errors };
-    }
-    const primaryExpression = parseBlockParameterToBinding(ast.parameters[0], bindingParser);
+    const primaryExpression = ast.parameters.length > 0 ?
+        parseBlockParameterToBinding(ast.parameters[0], bindingParser) :
+        bindingParser.parseBinding('', false, ast.sourceSpan, 0);
     const cases = [];
+    const unknownBlocks = [];
     let defaultCase = null;
     // Here we assume that all the blocks are valid given that we validated them above.
     for (const node of ast.children) {
         if (!(node instanceof Block)) {
             continue;
         }
+        if ((node.name !== 'case' || node.parameters.length === 0) && node.name !== 'default') {
+            unknownBlocks.push(new UnknownBlock(node.name, node.sourceSpan));
+            continue;
+        }
         const expression = node.name === 'case' ?
             parseBlockParameterToBinding(node.parameters[0], bindingParser) :
             null;
-        const ast = new SwitchBlockCase(expression, visitAll(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan);
+        const ast = new SwitchBlockCase(expression, visitAll(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan, node.endSourceSpan);
         if (expression === null) {
             defaultCase = ast;
         }
@@ -23499,7 +23981,7 @@ function createSwitchBlock(ast, visitor, bindingParser) {
         cases.push(defaultCase);
     }
     return {
-        node: new SwitchBlock(primaryExpression, cases, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+        node: new SwitchBlock(primaryExpression, cases, unknownBlocks, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
         errors
     };
 }
@@ -23543,8 +24025,10 @@ function parseForLoopParameters(block, errors, bindingParser) {
     // Fill out any variables that haven't been defined explicitly.
     for (const variableName of ALLOWED_FOR_LOOP_LET_VARIABLES) {
         if (!result.context.hasOwnProperty(variableName)) {
-            result.context[variableName] =
-                new Variable(variableName, variableName, block.startSourceSpan, block.startSourceSpan);
+            // Give ambiently-available context variables empty spans at the end of the start of the `for`
+            // block, since they are not explicitly defined.
+            const emptySpanAfterForBlockStart = new ParseSourceSpan(block.startSourceSpan.end, block.startSourceSpan.end);
+            result.context[variableName] = new Variable(variableName, variableName, emptySpanAfterForBlockStart, emptySpanAfterForBlockStart);
         }
     }
     return result;
@@ -24039,7 +24523,17 @@ function createDeferredBlock(ast, connectedBlocks, visitor, bindingParser) {
     const errors = [];
     const { placeholder, loading, error } = parseConnectedBlocks(connectedBlocks, errors, visitor);
     const { triggers, prefetchTriggers } = parsePrimaryTriggers(ast.parameters, bindingParser, errors, placeholder);
-    const node = new DeferredBlock(visitAll(visitor, ast.children, ast.children), triggers, prefetchTriggers, placeholder, loading, error, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+    // The `defer` block has a main span encompassing all of the connected branches as well. For the
+    // span of only the first "main" branch, use `mainSourceSpan`.
+    let lastEndSourceSpan = ast.endSourceSpan;
+    let endOfLastSourceSpan = ast.sourceSpan.end;
+    if (connectedBlocks.length > 0) {
+        const lastConnectedBlock = connectedBlocks[connectedBlocks.length - 1];
+        lastEndSourceSpan = lastConnectedBlock.endSourceSpan;
+        endOfLastSourceSpan = lastConnectedBlock.sourceSpan.end;
+    }
+    const mainDeferredSourceSpan = new ParseSourceSpan(ast.sourceSpan.start, endOfLastSourceSpan);
+    const node = new DeferredBlock(visitAll(visitor, ast.children, ast.children), triggers, prefetchTriggers, placeholder, loading, error, mainDeferredSourceSpan, ast.sourceSpan, ast.startSourceSpan, lastEndSourceSpan);
     return { node, errors };
 }
 function parseConnectedBlocks(connectedBlocks, errors, visitor) {
@@ -24445,7 +24939,10 @@ class HtmlAstToIvyAst {
                 else {
                     errorMessage = `Unrecognized block @${block.name}.`;
                 }
-                result = { node: null, errors: [new ParseError(block.sourceSpan, errorMessage)] };
+                result = {
+                    node: new UnknownBlock(block.name, block.sourceSpan),
+                    errors: [new ParseError(block.sourceSpan, errorMessage)],
+                };
                 break;
         }
         this.errors.push(...result.errors);
@@ -24686,19 +25183,6 @@ function textContents(node) {
     }
 }
 
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/**
- * Whether the @ block syntax is enabled by default. This constant exists
- * so that we can temporarily disable the syntax internally.
- */
-const BLOCK_SYNTAX_ENABLED_DEFAULT = true;
-
 var TagType;
 (function (TagType) {
     TagType[TagType["ELEMENT"] = 0] = "ELEMENT";
@@ -25046,6 +25530,7 @@ class TemplateDefinitionBuilder {
         this.visitIfBlockBranch = invalid;
         this.visitSwitchBlockCase = invalid;
         this.visitForLoopBlockEmpty = invalid;
+        this.visitUnknownBlock = invalid;
         this._bindingScope = parentBindingScope.nestedScope(level);
         // Turn the relative context file path into an identifier by replacing non-alphanumeric
         // characters with underscores.
@@ -25771,18 +26256,17 @@ class TemplateDefinitionBuilder {
         // callback in order to generate the correct expressions when pipes or pure functions are
         // used inside the branch expressions.
         const branchData = block.branches.map(({ expression, expressionAlias, children, sourceSpan }) => {
-            const processedExpression = expression === null ? null : expression.visit(this._valueConverter);
             // If the branch has an alias, it'll be assigned directly to the container's context.
             // We define a variable referring directly to the context so that any nested usages can be
             // rewritten to refer to it.
             const variables = expressionAlias !== null ?
                 [new Variable(expressionAlias.name, DIRECT_CONTEXT_REFERENCE, expressionAlias.sourceSpan, expressionAlias.keySpan)] :
                 undefined;
-            return {
-                index: this.createEmbeddedTemplateFn(null, children, '_Conditional', sourceSpan, variables),
-                expression: processedExpression,
-                alias: expressionAlias
-            };
+            // Note: the template needs to be created *before* we process the expression,
+            // otherwise pipes injecting some symbols won't work (see #52102).
+            const index = this.createEmbeddedTemplateFn(null, children, '_Conditional', sourceSpan, variables);
+            const processedExpression = expression === null ? null : expression.visit(this._valueConverter);
+            return { index, expression: processedExpression, alias: expressionAlias };
         });
         // Use the index of the first block as the index for the entire container.
         const containerIndex = branchData[0].index;
@@ -25828,20 +26312,21 @@ class TemplateDefinitionBuilder {
         this.updateInstructionWithAdvance(containerIndex, block.branches[0].sourceSpan, Identifiers.conditional, paramsCallback);
     }
     visitSwitchBlock(block) {
-        const blockExpression = block.expression.visit(this._valueConverter);
-        this.allocateBindingSlots(null); // Allocate a slot for the primary block expression.
         // We have to process the block in two steps: once here and again in the update instruction
         // callback in order to generate the correct expressions when pipes or pure functions are used.
         const caseData = block.cases.map(currentCase => {
-            return {
-                index: this.createEmbeddedTemplateFn(null, currentCase.children, '_Case', currentCase.sourceSpan),
-                expression: currentCase.expression === null ?
-                    null :
-                    currentCase.expression.visit(this._valueConverter)
-            };
+            const index = this.createEmbeddedTemplateFn(null, currentCase.children, '_Case', currentCase.sourceSpan);
+            const expression = currentCase.expression === null ?
+                null :
+                currentCase.expression.visit(this._valueConverter);
+            return { index, expression };
         });
         // Use the index of the first block as the index for the entire container.
         const containerIndex = caseData[0].index;
+        // Note: the expression needs to be processed *after* the template,
+        // otherwise pipes injecting some symbols won't work (see #52102).
+        const blockExpression = block.expression.visit(this._valueConverter);
+        this.allocateBindingSlots(null); // Allocate a slot for the primary block expression.
         this.updateInstructionWithAdvance(containerIndex, block.sourceSpan, Identifiers.conditional, () => {
             const generateCases = (caseIndex) => {
                 // If we've gone beyond the last branch, return the special -1
@@ -25909,12 +26394,17 @@ class TemplateDefinitionBuilder {
             literal(errorIndex),
             loadingConsts?.length ? this.addToConsts(literalArr(loadingConsts)) : TYPED_NULL_EXPR,
             placeholderConsts ? this.addToConsts(placeholderConsts) : TYPED_NULL_EXPR,
+            (loadingConsts?.length || placeholderConsts) ?
+                importExpr(Identifiers.deferEnableTimerScheduling) :
+                TYPED_NULL_EXPR,
         ]));
-        this.createDeferTriggerInstructions(deferredIndex, triggers, metadata, false);
-        this.createDeferTriggerInstructions(deferredIndex, prefetchTriggers, metadata, true);
         // Allocate an extra data slot right after a defer block slot to store
         // instance-specific state of that defer block at runtime.
         this.allocateDataSlot();
+        // Note: the triggers need to be processed *after* the various templates,
+        // otherwise pipes injecting some symbols won't work (see #52102).
+        this.createDeferTriggerInstructions(deferredIndex, triggers, metadata, false);
+        this.createDeferTriggerInstructions(deferredIndex, prefetchTriggers, metadata, true);
     }
     createDeferredDepsFunction(name, metadata) {
         if (metadata.deps.length === 0) {
@@ -26006,12 +26496,13 @@ class TemplateDefinitionBuilder {
         // are implicitly inferred by the runtime to index + 1 and index + 2.
         const blockIndex = this.allocateDataSlot();
         const primaryData = this.prepareEmbeddedTemplateFn(block.children, '_For', [block.item, block.contextVariables.$index, block.contextVariables.$count]);
-        const emptyData = block.empty === null ?
-            null :
-            this.prepareEmbeddedTemplateFn(block.empty.children, '_ForEmpty');
         const { expression: trackByExpression, usesComponentInstance: trackByUsesComponentInstance } = this.createTrackByFunction(block);
-        const value = block.expression.visit(this._valueConverter);
-        this.allocateBindingSlots(value);
+        let emptyData = null;
+        if (block.empty !== null) {
+            emptyData = this.prepareEmbeddedTemplateFn(block.empty.children, '_ForEmpty');
+            // Allocate an extra slot for the empty block tracking.
+            this.allocateBindingSlots(null);
+        }
         this.registerComputedLoopVariables(block, primaryData.scope);
         // `repeaterCreate(0, ...)`
         this.creationInstruction(block.sourceSpan, Identifiers.repeaterCreate, () => {
@@ -26031,6 +26522,11 @@ class TemplateDefinitionBuilder {
             }
             return params;
         });
+        // Note: the expression needs to be processed *after* the template,
+        // otherwise pipes injecting some symbols won't work (see #52102).
+        // Note: we don't allocate binding slots for this expression,
+        // because its value isn't stored in the LView.
+        const value = block.expression.visit(this._valueConverter);
         // `repeater(0, iterable)`
         this.updateInstruction(block.sourceSpan, Identifiers.repeater, () => [literal(blockIndex), this.convertPropertyBinding(value)]);
     }
@@ -26906,7 +27402,7 @@ function parseTemplate(template, templateUrl, options = {}) {
         leadingTriviaChars: LEADING_TRIVIA_CHARS,
         ...options,
         tokenizeExpansionForms: true,
-        tokenizeBlocks: options.enableBlockSyntax ?? BLOCK_SYNTAX_ENABLED_DEFAULT,
+        tokenizeBlocks: options.enableBlockSyntax ?? true,
     });
     if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors &&
         parseResult.errors.length > 0) {
@@ -28051,6 +28547,7 @@ class Scope {
     visitTextAttribute(attr) { }
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
+    visitUnknownBlock(block) { }
     maybeDeclare(thing) {
         // Declare something with a name, as long as that name isn't taken.
         if (!this.namedEntities.has(thing.name)) {
@@ -28252,6 +28749,7 @@ class DirectiveBinder {
     visitBoundText(text) { }
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
+    visitUnknownBlock(block) { }
 }
 /**
  * Processes a template and extract metadata about expressions and symbols within.
@@ -28380,6 +28878,8 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitText(text) { }
     visitContent(content) { }
     visitTextAttribute(attribute) { }
+    visitUnknownBlock(block) { }
+    visitDeferredTrigger() { }
     visitIcu(icu) {
         Object.keys(icu.vars).forEach(key => icu.vars[key].visit(this));
         Object.keys(icu.placeholders).forEach(key => icu.placeholders[key].visit(this));
@@ -28394,15 +28894,12 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitDeferredBlock(deferred) {
         this.deferBlocks.add(deferred);
         this.ingestScopedNode(deferred);
+        deferred.triggers.when?.value.visit(this);
+        deferred.prefetchTriggers.when?.value.visit(this);
         deferred.placeholder && this.visitNode(deferred.placeholder);
         deferred.loading && this.visitNode(deferred.loading);
         deferred.error && this.visitNode(deferred.error);
     }
-    visitDeferredTrigger(trigger) {
-        if (trigger instanceof BoundDeferredTrigger) {
-            trigger.value.visit(this);
-        }
-    }
     visitDeferredBlockPlaceholder(block) {
         this.ingestScopedNode(block);
     }
@@ -29259,13 +29756,11 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.0.0-next.7');
+const VERSION = new Version('17.0.0-rc.0');
 
 class CompilerConfig {
-    constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, useJit = true, missingTranslation = null, preserveWhitespaces, strictInjectionParameters } = {}) {
+    constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
         this.defaultEncapsulation = defaultEncapsulation;
-        this.useJit = !!useJit;
-        this.missingTranslation = missingTranslation;
         this.preserveWhitespaces = preserveWhitespacesDefault(noUndefined(preserveWhitespaces));
         this.strictInjectionParameters = strictInjectionParameters === true;
     }
@@ -30755,6 +31250,31 @@ function compileComponentClassMetadata(metadata, deferrableTypes) {
     return iife.callFn([]);
 }
 
+/**
+ * Generate an ngDevMode guarded call to setClassDebugInfo with the debug info about the class
+ * (e.g., the file name in which the class is defined)
+ */
+function compileClassDebugInfo(debugInfo) {
+    const debugInfoObject = {
+        className: debugInfo.className,
+    };
+    // Include file path and line number only if the file relative path is calculated successfully.
+    if (debugInfo.filePath) {
+        debugInfoObject.filePath = debugInfo.filePath;
+        debugInfoObject.lineNumber = debugInfo.lineNumber;
+    }
+    // Include forbidOrphanRendering only if it's set to true (to reduce generated code)
+    if (debugInfo.forbidOrphanRendering) {
+        debugInfoObject.forbidOrphanRendering = literal(true);
+    }
+    const fnCall = importExpr(Identifiers.setClassDebugInfo).callFn([
+        debugInfo.type,
+        mapLiteral(debugInfoObject),
+    ]);
+    const iife = arrowFn([], [devOnlyGuardedExpression(fnCall).toStmt()]);
+    return iife.callFn([]);
+}
+
 /**
  * Every time we make a breaking change to the declaration interface or partial-linker behavior, we
  * must update this constant to prevent old partial-linkers from incorrectly processing the
@@ -30766,7 +31286,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('17.0.0-next.7'));
+    definitionMap.set('version', literal('17.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -30874,7 +31394,7 @@ function createDirectiveDefinitionMap(meta) {
     // in 16.1 is actually used.
     const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION$5 : '14.0.0';
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('17.0.0-next.7'));
+    definitionMap.set('version', literal('17.0.0-rc.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -31151,7 +31671,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('17.0.0-next.7'));
+    definitionMap.set('version', literal('17.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -31186,7 +31706,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('17.0.0-next.7'));
+    definitionMap.set('version', literal('17.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -31237,7 +31757,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('17.0.0-next.7'));
+    definitionMap.set('version', literal('17.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -31270,7 +31790,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('17.0.0-next.7'));
+    definitionMap.set('version', literal('17.0.0-rc.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.
@@ -31321,7 +31841,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('17.0.0-next.7'));
+    definitionMap.set('version', literal('17.0.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -31354,5 +31874,5 @@ publishFacade(_global);
 
 // This file is not used to build this module. It is only used during editing
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, UnknownBlock as TmplAstUnknownBlock, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map