@angular/compiler 17.0.0-next.7 → 17.0.0-next.8

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.7
+ * @license Angular v17.0.0-next.8
  * (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 = [];
@@ -9297,10 +9317,11 @@ function createConditionalOp(target, test, conditions, sourceSpan) {
 /**
  * Create an i18n expression op.
  */
-function createI18nExpressionOp(target, expression, i18nPlaceholder, sourceSpan) {
+function createI18nExpressionOp(owner, expression, i18nPlaceholder, sourceSpan) {
     return {
         kind: OpKind.I18nExpression,
-        target,
+        owner,
+        target: owner,
         expression,
         i18nPlaceholder,
         sourceSpan,
@@ -10448,7 +10469,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 +10481,7 @@ function createTemplateOp(xref, tag, namespace, generatedInBlock, i18n, sourceSp
         localRefs: [],
         nonBindable: false,
         namespace,
+        i18nPlaceholder,
         sourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
@@ -10633,13 +10655,15 @@ 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(),
         messageIndex: null,
+        subTemplateIndex: null,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -11019,7 +11043,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 +11057,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 +11842,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
@@ -12123,9 +12154,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.kind === OpKind.I18n) {
+                op.messageIndex = messageConstIndices[op.root];
             }
         }
     }
@@ -17078,7 +17108,7 @@ class _Tokenizer {
                 this.handleError(e);
             }
         }
-        this._beginToken(28 /* TokenType.EOF */);
+        this._beginToken(29 /* TokenType.EOF */);
         this._endToken([]);
     }
     _getBlockName() {
@@ -17099,7 +17129,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 +17137,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 +18125,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 +18157,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 +18234,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 +18274,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 +18476,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;
@@ -18998,16 +19054,19 @@ function phaseI18nMessageExtraction(job) {
     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));
+                // 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);
+                    // TODO: figure out transformFn.
+                    const statements = getTranslationDeclStmts$1(op.message, mainVar, closureVar, params, undefined /*transformFn*/);
+                    unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
+                }
             }
         }
     }
@@ -19739,6 +19798,86 @@ 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 phasePropagateI18nPlaceholders(job) {
+    // Get all of the i18n ops.
+    const i18nOps = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.I18nStart) {
+                i18nOps.set(op.xref, op);
+            }
+        }
+    }
+    // Propagate i18n params from sub-templates up to the root i18n op.
+    for (const op of i18nOps.values()) {
+        if (op.xref !== op.root) {
+            const rootOp = i18nOps.get(op.root);
+            for (const [placeholder, value] of op.params) {
+                rootOp.params.set(placeholder, value);
+            }
+        }
+    }
+    // Validate the root i18n ops have all placeholders filled in.
+    for (const op of i18nOps.values()) {
+        if (op.xref === op.root) {
+            for (const placeholder in op.message.placeholders) {
+                if (!op.params.has(placeholder)) {
+                    throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
+                }
+            }
+        }
+    }
+}
+
 function phasePureFunctionExtraction(job) {
     for (const view of job.units) {
         for (const op of view.ops()) {
@@ -19975,11 +20114,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 +20509,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 +20853,181 @@ 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 = '|';
+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 closing of a tag. (Can only be used together with ElementTag or
+     * TemplateTag)
+     */
+    I18nParamValueFlags[I18nParamValueFlags["CloseTag"] = 4] = "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, flags) {
+        const placeholderValues = this.values.get(placeholder) ?? [];
+        placeholderValues.push({ value, subTemplateIndex, 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) {
+            op.params.set(placeholder, literal(this.serializeValues(placeholderValues)));
+        }
+    }
+    /**
+     * Serializes a list of i18n placeholder values.
+     */
+    serializeValues(values) {
+        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}`;
+        return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+    }
+}
 /**
  * Resolve the placeholders in i18n messages.
  */
 function phaseResolveI18nPlaceholders(job) {
     for (const unit of job.units) {
         const i18nOps = new Map();
-        let startTagSlots = new Map();
-        let closeTagSlots = new Map();
+        const params = 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) {
+                case OpKind.Template:
+                    // For elements with i18n placeholders, record its slot value in the params map under both
+                    // the start and close placeholders.
+                    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');
-                        }
                         const { startName, closeName } = op.i18nPlaceholder;
-                        addTagSlot(startTagSlots, startName, op.slot);
-                        addTagSlot(closeTagSlots, closeName, op.slot);
+                        const subTemplateIndex = getSubTemplateIndexForTag(job, currentI18nOp, op);
+                        const flags = op.kind === OpKind.Template ? I18nParamValueFlags.TemplateTag :
+                            I18nParamValueFlags.ElementTag;
+                        addParam(params, currentI18nOp, startName, op.slot, subTemplateIndex, flags);
+                        addParam(params, currentI18nOp, closeName, op.slot, subTemplateIndex, flags | I18nParamValueFlags.CloseTag);
                     }
                     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);
+                addParam(params, i18nOp, op.i18nPlaceholder.name, index++, i18nOp.subTemplateIndex);
+                i18nBlockPlaceholderIndices.set(op.owner, 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}`);
-                }
-            }
+        // After colleccting all params, save them to the i18n ops.
+        for (const [xref, i18nOpParams] of params) {
+            i18nOpParams.saveToOp(i18nOps.get(xref));
         }
     }
 }
 /**
- * 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, flags = I18nParamValueFlags.None) {
+    const i18nOpParams = params.get(i18nOp.xref) ?? new I18nPlaceholderParams();
+    i18nOpParams.addValue(placeholder, value, subTemplateIndex, flags);
+    params.set(i18nOp.xref, i18nOpParams);
 }
 /**
- * Serializes a list of slots to a string literal expression.
+ * Get the subTemplateIndex for the given op. For template ops, use the subTemplateIndex of the
+ * child i18n block inside the template. For all other ops, use the subTemplateIndex of the i18n
+ * block the op belongs to.
  */
-function serializeSlots(slots, start) {
-    const slotStrings = slots.map(slot => `${ESCAPE}${start ? '' : '/'}#${slot}${ESCAPE}`);
-    if (slotStrings.length === 1) {
-        return literal(slotStrings[0]);
+function getSubTemplateIndexForTag(job, i18nOp, op) {
+    if (op.kind === OpKind.Template) {
+        for (const childOp of job.views.get(op.xref).create) {
+            if (childOp.kind === OpKind.I18nStart) {
+                return childOp.subTemplateIndex;
+            }
+        }
     }
-    return literal(`[${slotStrings.join('|')}]`);
+    return i18nOp.subTemplateIndex;
 }
 
 /**
@@ -21559,6 +21791,7 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: phaseNamespace },
     { kind: CompilationJobKind.Both, fn: phaseStyleBindingSpecialization },
     { kind: CompilationJobKind.Both, fn: phaseBindingSpecialization },
+    { kind: CompilationJobKind.Tmpl, fn: phasePropagateI18nBlocks },
     { kind: CompilationJobKind.Both, fn: phaseAttributeExtraction },
     { kind: CompilationJobKind.Both, fn: phaseParseExtractedStyles },
     { kind: CompilationJobKind.Tmpl, fn: phaseRemoveEmptyBindings },
@@ -21582,10 +21815,12 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: phaseTemporaryVariables },
     { kind: CompilationJobKind.Tmpl, fn: phaseSlotAllocation },
     { kind: CompilationJobKind.Tmpl, fn: phaseResolveI18nPlaceholders },
+    { kind: CompilationJobKind.Tmpl, fn: phasePropagateI18nPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: phaseI18nMessageExtraction },
     { 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 },
@@ -21835,7 +22070,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 +22080,9 @@ function ingestTemplate(unit, tmpl) {
     if (tmpl.tagName) {
         [namespacePrefix, tagNameWithoutNamespace] = splitNsName(tmpl.tagName);
     }
+    const i18nPlaceholder = tmpl.i18n instanceof TagPlaceholder ? tmpl.i18n : undefined;
     // TODO: validate the fallback tag name here.
-    const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace ?? 'ng-template', namespaceForKey(namespacePrefix), false, undefined, tmpl.startSourceSpan);
+    const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace ?? 'ng-template', namespaceForKey(namespacePrefix), false, i18nPlaceholder, tmpl.startSourceSpan);
     unit.create.push(tplOp);
     ingestBindings(unit, tplOp, tmpl);
     ingestReferences(tplOp, tmpl);
@@ -21888,7 +22125,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 +22152,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 +22172,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;
@@ -23385,13 +23622,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 +23649,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 +23694,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 +23703,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 +23720,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 +23751,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 +23795,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 +24293,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 +24709,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 +24953,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 +25300,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 +26026,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 +26082,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 +26164,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 +26266,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 +26292,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 +27172,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 +28317,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 +28519,7 @@ class DirectiveBinder {
     visitBoundText(text) { }
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
+    visitUnknownBlock(block) { }
 }
 /**
  * Processes a template and extract metadata about expressions and symbols within.
@@ -28380,6 +28648,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 +28664,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 +29526,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-next.8');
 
 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 +31020,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 +31056,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-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -30874,7 +31164,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-next.8'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -31151,7 +31441,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-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -31186,7 +31476,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-next.8'));
     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 +31527,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-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -31270,7 +31560,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-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -31321,7 +31611,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-next.8'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -31354,5 +31644,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