@angular/compiler 20.0.0-next.0 → 20.0.0-next.2

package/fesm2022/compiler.mjs

@@ -1,6 +1,6 @@
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
@@ -399,6 +399,10 @@ class SelectorContext {
 }
 
 // Attention:
+// This file duplicates types and values from @angular/core
+// so that we are able to make @angular/compiler independent of @angular/core.
+// This is important to prevent a build cycle, as @angular/core needs to
+// be compiled with the compiler.
 // Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not
 // explicitly set.
 const emitDistinctChangesOnlyDefaultValue = true;
@@ -484,15 +488,15 @@ function parseSelectorToR3Selector(selector) {
 
 var core = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    emitDistinctChangesOnlyDefaultValue: emitDistinctChangesOnlyDefaultValue,
-    get ViewEncapsulation () { return ViewEncapsulation; },
+    CUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA,
     get ChangeDetectionStrategy () { return ChangeDetectionStrategy; },
     get InputFlags () { return InputFlags; },
-    CUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA,
+    get MissingTranslationStrategy () { return MissingTranslationStrategy; },
     NO_ERRORS_SCHEMA: NO_ERRORS_SCHEMA,
-    Type: Type$1,
     get SecurityContext () { return SecurityContext; },
-    get MissingTranslationStrategy () { return MissingTranslationStrategy; },
+    Type: Type$1,
+    get ViewEncapsulation () { return ViewEncapsulation; },
+    emitDistinctChangesOnlyDefaultValue: emitDistinctChangesOnlyDefaultValue,
     parseSelectorToR3Selector: parseSelectorToR3Selector
 });
 
@@ -663,7 +667,7 @@ function fingerprint(str) {
     let lo = hash32(view, utf8.length, 102072);
     if (hi == 0 && (lo == 0 || lo == 1)) {
         hi = hi ^ 0x130f9bef;
-        lo = lo ^ -0x6b5f56d8;
+        lo = lo ^ -1801410264;
     }
     return (BigInt.asUintN(32, BigInt(hi)) << BigInt(32)) | BigInt.asUintN(32, BigInt(lo));
 }
@@ -1001,11 +1005,11 @@ class Expression {
     and(rhs, sourceSpan) {
         return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);
     }
-    bitwiseOr(rhs, sourceSpan, parens = true) {
-        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
+    bitwiseOr(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan);
     }
-    bitwiseAnd(rhs, sourceSpan, parens = true) {
-        return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);
+    bitwiseAnd(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan);
     }
     or(rhs, sourceSpan) {
         return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);
@@ -1678,16 +1682,34 @@ class UnaryOperatorExpr extends Expression {
         return new UnaryOperatorExpr(this.operator, this.expr.clone(), this.type, this.sourceSpan, this.parens);
     }
 }
+class ParenthesizedExpr extends Expression {
+    expr;
+    constructor(expr, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.expr = expr;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitParenthesizedExpr(this, context);
+    }
+    isEquivalent(e) {
+        // TODO: should this ignore paren depth? i.e. is `(1)` equivalent to `1`?
+        return e instanceof ParenthesizedExpr && e.expr.isEquivalent(this.expr);
+    }
+    isConstant() {
+        return this.expr.isConstant();
+    }
+    clone() {
+        return new ParenthesizedExpr(this.expr.clone());
+    }
+}
 class BinaryOperatorExpr extends Expression {
     operator;
     rhs;
-    parens;
     lhs;
-    constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {
+    constructor(operator, lhs, rhs, type, sourceSpan) {
         super(type || lhs.type, sourceSpan);
         this.operator = operator;
         this.rhs = rhs;
-        this.parens = parens;
         this.lhs = lhs;
     }
     isEquivalent(e) {
@@ -1703,7 +1725,7 @@ class BinaryOperatorExpr extends Expression {
         return visitor.visitBinaryOperatorExpr(this, context);
     }
     clone() {
-        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan, this.parens);
+        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan);
     }
 }
 class ReadPropExpr extends Expression {
@@ -1975,7 +1997,7 @@ class IfStmt extends Statement {
         return visitor.visitIfStmt(this, context);
     }
 }
-class RecursiveAstVisitor$1 {
+let RecursiveAstVisitor$1 = class RecursiveAstVisitor {
     visitType(ast, context) {
         return ast;
     }
@@ -2007,12 +2029,6 @@ class RecursiveAstVisitor$1 {
     visitWrappedNodeExpr(ast, context) {
         return ast;
     }
-    visitTypeofExpr(ast, context) {
-        return this.visitExpression(ast, context);
-    }
-    visitVoidExpr(ast, context) {
-        return this.visitExpression(ast, context);
-    }
     visitReadVarExpr(ast, context) {
         return this.visitExpression(ast, context);
     }
@@ -2090,6 +2106,14 @@ class RecursiveAstVisitor$1 {
         ast.expr.visitExpression(this, context);
         return this.visitExpression(ast, context);
     }
+    visitTypeofExpr(ast, context) {
+        ast.expr.visitExpression(this, context);
+        return this.visitExpression(ast, context);
+    }
+    visitVoidExpr(ast, context) {
+        ast.expr.visitExpression(this, context);
+        return this.visitExpression(ast, context);
+    }
     visitBinaryOperatorExpr(ast, context) {
         ast.lhs.visitExpression(this, context);
         ast.rhs.visitExpression(this, context);
@@ -2124,6 +2148,10 @@ class RecursiveAstVisitor$1 {
     visitTemplateLiteralElementExpr(ast, context) {
         return this.visitExpression(ast, context);
     }
+    visitParenthesizedExpr(ast, context) {
+        ast.expr.visitExpression(this, context);
+        return this.visitExpression(ast, context);
+    }
     visitAllExpressions(exprs, context) {
         exprs.forEach((expr) => expr.visitExpression(this, context));
     }
@@ -2160,7 +2188,7 @@ class RecursiveAstVisitor$1 {
     visitAllStatements(stmts, context) {
         stmts.forEach((stmt) => stmt.visitStatement(this, context));
     }
-}
+};
 function leadingComment(text, multiline = false, trailingNewline = true) {
     return new LeadingComment(text, multiline, trailingNewline);
 }
@@ -2255,90 +2283,91 @@ function serializeTags(tags) {
 
 var output_ast = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get TypeModifier () { return TypeModifier; },
-    Type: Type,
-    get BuiltinTypeName () { return BuiltinTypeName; },
-    BuiltinType: BuiltinType,
-    ExpressionType: ExpressionType,
     ArrayType: ArrayType,
-    MapType: MapType,
-    TransplantedType: TransplantedType,
-    DYNAMIC_TYPE: DYNAMIC_TYPE,
-    INFERRED_TYPE: INFERRED_TYPE,
+    ArrowFunctionExpr: ArrowFunctionExpr,
     BOOL_TYPE: BOOL_TYPE,
-    INT_TYPE: INT_TYPE,
-    NUMBER_TYPE: NUMBER_TYPE,
-    STRING_TYPE: STRING_TYPE,
-    FUNCTION_TYPE: FUNCTION_TYPE,
-    NONE_TYPE: NONE_TYPE,
-    get UnaryOperator () { return UnaryOperator; },
     get BinaryOperator () { return BinaryOperator; },
-    nullSafeIsEquivalent: nullSafeIsEquivalent,
-    areAllEquivalent: areAllEquivalent,
+    BinaryOperatorExpr: BinaryOperatorExpr,
+    BuiltinType: BuiltinType,
+    get BuiltinTypeName () { return BuiltinTypeName; },
+    CommaExpr: CommaExpr,
+    ConditionalExpr: ConditionalExpr,
+    DYNAMIC_TYPE: DYNAMIC_TYPE,
+    DeclareFunctionStmt: DeclareFunctionStmt,
+    DeclareVarStmt: DeclareVarStmt,
+    DynamicImportExpr: DynamicImportExpr,
     Expression: Expression,
-    ReadVarExpr: ReadVarExpr,
-    TypeofExpr: TypeofExpr,
-    VoidExpr: VoidExpr,
-    WrappedNodeExpr: WrappedNodeExpr,
-    WriteVarExpr: WriteVarExpr,
-    WriteKeyExpr: WriteKeyExpr,
-    WritePropExpr: WritePropExpr,
-    InvokeFunctionExpr: InvokeFunctionExpr,
-    TaggedTemplateLiteralExpr: TaggedTemplateLiteralExpr,
-    InstantiateExpr: InstantiateExpr,
-    LiteralExpr: LiteralExpr,
-    TemplateLiteralExpr: TemplateLiteralExpr,
-    TemplateLiteralElementExpr: TemplateLiteralElementExpr,
-    LiteralPiece: LiteralPiece,
-    PlaceholderPiece: PlaceholderPiece,
-    LocalizedString: LocalizedString,
+    ExpressionStatement: ExpressionStatement,
+    ExpressionType: ExpressionType,
     ExternalExpr: ExternalExpr,
     ExternalReference: ExternalReference,
-    ConditionalExpr: ConditionalExpr,
-    DynamicImportExpr: DynamicImportExpr,
-    NotExpr: NotExpr,
+    FUNCTION_TYPE: FUNCTION_TYPE,
     FnParam: FnParam,
     FunctionExpr: FunctionExpr,
-    ArrowFunctionExpr: ArrowFunctionExpr,
-    UnaryOperatorExpr: UnaryOperatorExpr,
-    BinaryOperatorExpr: BinaryOperatorExpr,
-    ReadPropExpr: ReadPropExpr,
-    ReadKeyExpr: ReadKeyExpr,
+    INFERRED_TYPE: INFERRED_TYPE,
+    INT_TYPE: INT_TYPE,
+    IfStmt: IfStmt,
+    InstantiateExpr: InstantiateExpr,
+    InvokeFunctionExpr: InvokeFunctionExpr,
+    JSDocComment: JSDocComment,
+    LeadingComment: LeadingComment,
     LiteralArrayExpr: LiteralArrayExpr,
+    LiteralExpr: LiteralExpr,
     LiteralMapEntry: LiteralMapEntry,
     LiteralMapExpr: LiteralMapExpr,
-    CommaExpr: CommaExpr,
+    LiteralPiece: LiteralPiece,
+    LocalizedString: LocalizedString,
+    MapType: MapType,
+    NONE_TYPE: NONE_TYPE,
     NULL_EXPR: NULL_EXPR,
-    TYPED_NULL_EXPR: TYPED_NULL_EXPR,
-    get StmtModifier () { return StmtModifier; },
-    LeadingComment: LeadingComment,
-    JSDocComment: JSDocComment,
-    Statement: Statement,
-    DeclareVarStmt: DeclareVarStmt,
-    DeclareFunctionStmt: DeclareFunctionStmt,
-    ExpressionStatement: ExpressionStatement,
-    ReturnStatement: ReturnStatement,
-    IfStmt: IfStmt,
+    NUMBER_TYPE: NUMBER_TYPE,
+    NotExpr: NotExpr,
+    ParenthesizedExpr: ParenthesizedExpr,
+    PlaceholderPiece: PlaceholderPiece,
+    ReadKeyExpr: ReadKeyExpr,
+    ReadPropExpr: ReadPropExpr,
+    ReadVarExpr: ReadVarExpr,
     RecursiveAstVisitor: RecursiveAstVisitor$1,
-    leadingComment: leadingComment,
-    jsDocComment: jsDocComment,
-    variable: variable,
+    ReturnStatement: ReturnStatement,
+    STRING_TYPE: STRING_TYPE,
+    Statement: Statement,
+    get StmtModifier () { return StmtModifier; },
+    TYPED_NULL_EXPR: TYPED_NULL_EXPR,
+    TaggedTemplateLiteralExpr: TaggedTemplateLiteralExpr,
+    TemplateLiteralElementExpr: TemplateLiteralElementExpr,
+    TemplateLiteralExpr: TemplateLiteralExpr,
+    TransplantedType: TransplantedType,
+    Type: Type,
+    get TypeModifier () { return TypeModifier; },
+    TypeofExpr: TypeofExpr,
+    get UnaryOperator () { return UnaryOperator; },
+    UnaryOperatorExpr: UnaryOperatorExpr,
+    VoidExpr: VoidExpr,
+    WrappedNodeExpr: WrappedNodeExpr,
+    WriteKeyExpr: WriteKeyExpr,
+    WritePropExpr: WritePropExpr,
+    WriteVarExpr: WriteVarExpr,
+    areAllEquivalent: areAllEquivalent,
+    arrowFn: arrowFn,
+    expressionType: expressionType,
+    fn: fn,
+    ifStmt: ifStmt,
     importExpr: importExpr,
     importType: importType,
-    expressionType: expressionType,
-    transplantedType: transplantedType,
-    typeofExpr: typeofExpr,
+    isNull: isNull,
+    jsDocComment: jsDocComment,
+    leadingComment: leadingComment,
+    literal: literal,
     literalArr: literalArr,
     literalMap: literalMap,
-    unary: unary,
+    localizedString: localizedString,
     not: not,
-    fn: fn,
-    arrowFn: arrowFn,
-    ifStmt: ifStmt,
+    nullSafeIsEquivalent: nullSafeIsEquivalent,
     taggedTemplate: taggedTemplate,
-    literal: literal,
-    localizedString: localizedString,
-    isNull: isNull
+    transplantedType: transplantedType,
+    typeofExpr: typeofExpr,
+    unary: unary,
+    variable: variable
 });
 
 const CONSTANT_PREFIX = '_c';
@@ -3142,13 +3171,6 @@ function _splitAt(input, character, defaultValues) {
 function noUndefined(val) {
     return val === undefined ? null : val;
 }
-function error(msg) {
-    throw new Error(`Internal Error: ${msg}`);
-}
-// Escape characters that have a special meaning in Regular Expressions
-function escapeRegExp(s) {
-    return s.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
-}
 function utf8Encode(str) {
     let encoded = [];
     for (let index = 0; index < str.length; index++) {
@@ -3219,29 +3241,6 @@ class Version {
     }
 }
 const _global = globalThis;
-function newArray(size, value) {
-    const list = [];
-    for (let i = 0; i < size; i++) {
-        list.push(value);
-    }
-    return list;
-}
-/**
- * Partitions a given array into 2 arrays, based on a boolean value returned by the condition
- * function.
- *
- * @param arr Input array that should be partitioned
- * @param conditionFn Condition function that is called for each item in a given array and returns a
- * boolean value.
- */
-function partitionArray(arr, conditionFn) {
-    const truthy = [];
-    const falsy = [];
-    for (const item of arr) {
-        (conditionFn(item) ? truthy : falsy).push(item);
-    }
-    return [truthy, falsy];
-}
 const V1_TO_18 = /^([1-9]|1[0-8])\./;
 function getJitStandaloneDefaultForVersion(version) {
     if (version.startsWith('0.')) {
@@ -3548,6 +3547,7 @@ class EmitterVisitorContext {
 }
 class AbstractEmitterVisitor {
     _escapeDollarInStrings;
+    lastIfCondition = null;
     constructor(_escapeDollarInStrings) {
         this._escapeDollarInStrings = _escapeDollarInStrings;
     }
@@ -3587,7 +3587,9 @@ class AbstractEmitterVisitor {
     visitIfStmt(stmt, ctx) {
         this.printLeadingComments(stmt, ctx);
         ctx.print(stmt, `if (`);
+        this.lastIfCondition = stmt.condition; // We can skip redundant parentheses for the condition.
         stmt.condition.visitExpression(this, ctx);
+        this.lastIfCondition = null;
         ctx.print(stmt, `) {`);
         const hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;
         if (stmt.trueCase.length <= 1 && !hasElseCase) {
@@ -3760,11 +3762,12 @@ class AbstractEmitterVisitor {
             default:
                 throw new Error(`Unknown operator ${ast.operator}`);
         }
-        if (ast.parens)
+        const parens = ast !== this.lastIfCondition;
+        if (parens)
             ctx.print(ast, `(`);
         ctx.print(ast, opStr);
         ast.expr.visitExpression(this, ctx);
-        if (ast.parens)
+        if (parens)
             ctx.print(ast, `)`);
         return null;
     }
@@ -3831,12 +3834,13 @@ class AbstractEmitterVisitor {
             default:
                 throw new Error(`Unknown operator ${ast.operator}`);
         }
-        if (ast.parens)
+        const parens = ast !== this.lastIfCondition;
+        if (parens)
             ctx.print(ast, `(`);
         ast.lhs.visitExpression(this, ctx);
         ctx.print(ast, ` ${opStr} `);
         ast.rhs.visitExpression(this, ctx);
-        if (ast.parens)
+        if (parens)
             ctx.print(ast, `)`);
         return null;
     }
@@ -3874,6 +3878,12 @@ class AbstractEmitterVisitor {
         ctx.print(ast, ')');
         return null;
     }
+    visitParenthesizedExpr(ast, ctx) {
+        // We parenthesize everything regardless of an explicit ParenthesizedExpr, so we can just visit
+        // the inner expression.
+        // TODO: Do we *need* to parenthesize everything?
+        ast.expr.visitExpression(this, ctx);
+    }
     visitAllExpressions(expressions, ctx, separator) {
         this.visitAllObjects((expr) => expr.visitExpression(this, ctx), expressions, ctx, separator);
     }
@@ -3945,20 +3955,10 @@ function typeWithParameters(type, numParams) {
     }
     return expressionType(type, undefined, params);
 }
-const ANIMATE_SYMBOL_PREFIX = '@';
-function prepareSyntheticPropertyName(name) {
-    return `${ANIMATE_SYMBOL_PREFIX}${name}`;
-}
-function prepareSyntheticListenerName(name, phase) {
-    return `${ANIMATE_SYMBOL_PREFIX}${name}.${phase}`;
-}
 function getSafePropertyAccessString(accessor, name) {
     const escapedName = escapeIdentifier(name, false, false);
     return escapedName !== name ? `${accessor}[${escapedName}]` : `${accessor}.${name}`;
 }
-function prepareSyntheticListenerFunctionName(name, phase) {
-    return `animation_${name}_${phase}`;
-}
 function jitOnlyGuardedExpression(expr) {
     return guardedExpression('ngJitMode', expr);
 }
@@ -3970,7 +3970,7 @@ function guardedExpression(guard, expr) {
     const guardNotDefined = new BinaryOperatorExpr(BinaryOperator.Identical, new TypeofExpr(guardExpr), literal('undefined'));
     const guardUndefinedOrTrue = new BinaryOperatorExpr(BinaryOperator.Or, guardNotDefined, guardExpr, 
     /* type */ undefined, 
-    /* sourceSpan */ undefined, true);
+    /* sourceSpan */ undefined);
     return new BinaryOperatorExpr(BinaryOperator.And, guardUndefinedOrTrue, expr);
 }
 function wrapReference(value) {
@@ -4256,11 +4256,11 @@ class ASTWithName extends AST {
         this.nameSpan = nameSpan;
     }
 }
-class EmptyExpr$1 extends AST {
+let EmptyExpr$1 = class EmptyExpr extends AST {
     visit(visitor, context = null) {
         // do nothing
     }
-}
+};
 class ImplicitReceiver extends AST {
     visit(visitor, context = null) {
         return visitor.visitImplicitReceiver(this, context);
@@ -4428,7 +4428,7 @@ class LiteralMap extends AST {
         return visitor.visitLiteralMap(this, context);
     }
 }
-class Interpolation$1 extends AST {
+let Interpolation$1 = class Interpolation extends AST {
     strings;
     expressions;
     constructor(span, sourceSpan, strings, expressions) {
@@ -4439,7 +4439,7 @@ class Interpolation$1 extends AST {
     visit(visitor, context = null) {
         return visitor.visitInterpolation(this, context);
     }
-}
+};
 class Binary extends AST {
     operation;
     left;
@@ -4563,6 +4563,18 @@ class SafeCall extends AST {
         return visitor.visitSafeCall(this, context);
     }
 }
+class TaggedTemplateLiteral extends AST {
+    tag;
+    template;
+    constructor(span, sourceSpan, tag, template) {
+        super(span, sourceSpan);
+        this.tag = tag;
+        this.template = template;
+    }
+    visit(visitor, context) {
+        return visitor.visitTaggedTemplateLiteral(this, context);
+    }
+}
 class TemplateLiteral extends AST {
     elements;
     expressions;
@@ -4585,6 +4597,16 @@ class TemplateLiteralElement extends AST {
         return visitor.visitTemplateLiteralElement(this, context);
     }
 }
+class ParenthesizedExpression extends AST {
+    expression;
+    constructor(span, sourceSpan, expression) {
+        super(span, sourceSpan);
+        this.expression = expression;
+    }
+    visit(visitor, context) {
+        return visitor.visitParenthesizedExpression(this, context);
+    }
+}
 /**
  * Records the absolute position of a text span in a source file, where `start` and `end` are the
  * starting and ending byte offsets, respectively, of the text span in a source file.
@@ -4747,6 +4769,13 @@ class RecursiveAstVisitor {
         }
     }
     visitTemplateLiteralElement(ast, context) { }
+    visitTaggedTemplateLiteral(ast, context) {
+        this.visit(ast.tag, context);
+        this.visit(ast.template, context);
+    }
+    visitParenthesizedExpression(ast, context) {
+        this.visit(ast.expression, context);
+    }
     // This is not part of the AstVisitor interface, just a helper method
     visitAll(asts, context) {
         for (const ast of asts) {
@@ -4908,7 +4937,7 @@ function mergeNsAndName(prefix, localName) {
  * the top-level of the R3 AST, and only if `Render3ParseOptions['collectCommentNodes']`
  * is true.
  */
-class Comment$1 {
+let Comment$1 = class Comment {
     value;
     sourceSpan;
     constructor(value, sourceSpan) {
@@ -4918,8 +4947,8 @@ class Comment$1 {
     visit(_visitor) {
         throw new Error('visit() not implemented for Comment');
     }
-}
-class Text$3 {
+};
+let Text$3 = class Text {
     value;
     sourceSpan;
     constructor(value, sourceSpan) {
@@ -4929,7 +4958,7 @@ class Text$3 {
     visit(visitor) {
         return visitor.visitText(this);
     }
-}
+};
 class BoundText {
     value;
     sourceSpan;
@@ -5030,7 +5059,7 @@ class BoundEvent {
         return visitor.visitBoundEvent(this);
     }
 }
-class Element$1 {
+let Element$1 = class Element {
     name;
     attributes;
     inputs;
@@ -5056,7 +5085,7 @@ class Element$1 {
     visit(visitor) {
         return visitor.visitElement(this);
     }
-}
+};
 class DeferredTrigger {
     nameSpan;
     sourceSpan;
@@ -5327,7 +5356,7 @@ class UnknownBlock {
         return visitor.visitUnknownBlock(this);
     }
 }
-class LetDeclaration$1 {
+let LetDeclaration$1 = class LetDeclaration {
     name;
     value;
     sourceSpan;
@@ -5343,7 +5372,7 @@ class LetDeclaration$1 {
     visit(visitor) {
         return visitor.visitLetDeclaration(this);
     }
-}
+};
 class Template {
     tagName;
     attributes;
@@ -5432,7 +5461,7 @@ class Reference {
         return visitor.visitReference(this);
     }
 }
-class Icu$1 {
+let Icu$1 = class Icu {
     vars;
     placeholders;
     sourceSpan;
@@ -5446,8 +5475,8 @@ class Icu$1 {
     visit(visitor) {
         return visitor.visitIcu(this);
     }
-}
-class RecursiveVisitor$1 {
+};
+let RecursiveVisitor$1 = class RecursiveVisitor {
     visitElement(element) {
         visitAll$1(this, element.attributes);
         visitAll$1(this, element.inputs);
@@ -5511,7 +5540,7 @@ class RecursiveVisitor$1 {
     visitDeferredTrigger(trigger) { }
     visitUnknownBlock(block) { }
     visitLetDeclaration(decl) { }
-}
+};
 function visitAll$1(visitor, nodes) {
     const result = [];
     if (visitor.visit) {
@@ -5575,7 +5604,7 @@ class Message {
         }
     }
 }
-class Text$2 {
+let Text$2 = class Text {
     value;
     sourceSpan;
     constructor(value, sourceSpan) {
@@ -5585,7 +5614,7 @@ class Text$2 {
     visit(visitor, context) {
         return visitor.visitText(this, context);
     }
-}
+};
 // TODO(vicb): do we really need this node (vs an array) ?
 class Container {
     children;
@@ -5848,7 +5877,7 @@ class SimplePlaceholderMapper extends RecurseVisitor {
     }
 }
 
-class _Visitor$2 {
+let _Visitor$2 = class _Visitor {
     visitTag(tag) {
         const strAttrs = this._serializeAttributes(tag.attrs);
         if (tag.children.length == 0) {
@@ -5872,7 +5901,7 @@ class _Visitor$2 {
     visitDoctype(doctype) {
         return `<!DOCTYPE ${doctype.rootTag} [\n${doctype.dtd}\n]>`;
     }
-}
+};
 const _visitor = new _Visitor$2();
 function serialize$1(nodes) {
     return nodes.map((node) => node.visit(_visitor)).join('');
@@ -5914,7 +5943,7 @@ class Tag {
         return visitor.visitTag(this);
     }
 }
-class Text$1 {
+let Text$1 = class Text {
     value;
     constructor(unescapedValue) {
         this.value = escapeXml(unescapedValue);
@@ -5922,7 +5951,7 @@ class Text$1 {
     visit(visitor) {
         return visitor.visitText(this);
     }
-}
+};
 class CR extends Text$1 {
     constructor(ws = 0) {
         super(`\n${new Array(ws + 1).join(' ')}`);
@@ -6014,7 +6043,7 @@ class Xmb extends Serializer {
         return new SimplePlaceholderMapper(message, toPublicName);
     }
 }
-class _Visitor$1 {
+let _Visitor$1 = class _Visitor {
     visitText(text, context) {
         return [new Text$1(text.value)];
     }
@@ -6088,7 +6117,7 @@ class _Visitor$1 {
     serialize(nodes) {
         return [].concat(...nodes.map((node) => node.visit(this)));
     }
-}
+};
 function digest(message) {
     return decimalDigest(message);
 }
@@ -6132,13 +6161,6 @@ function hasI18nAttrs(element) {
 function icuFromI18nMessage(message) {
     return message.nodes[0];
 }
-function placeholdersToParams(placeholders) {
-    const params = {};
-    placeholders.forEach((values, key) => {
-        params[key] = literal(values.length > 1 ? `[${values.join('|')}]` : values[0]);
-    });
-    return params;
-}
 /**
  * Format the placeholder names in a map of placeholders to expressions.
  *
@@ -6216,9 +6238,6 @@ function temporaryAllocator(pushStatement, name) {
         return temp;
     };
 }
-function invalid(arg) {
-    throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);
-}
 function asLiteral(value) {
     if (Array.isArray(value)) {
         return literalArr(value.map(asLiteral));
@@ -6586,8 +6605,6 @@ const $LBRACE = 123;
 const $BAR = 124;
 const $RBRACE = 125;
 const $NBSP = 160;
-const $PIPE = 124;
-const $TILDA = 126;
 const $AT = 64;
 const $BT = 96;
 function isWhitespace(code) {
@@ -7300,9 +7317,7 @@ function compileNgModule(meta) {
             statements.push(setNgModuleScopeCall);
         }
     }
-    else {
-        // Selector scope emit was not requested, so skip it.
-    }
+    else ;
     if (meta.schemas !== null && meta.schemas.length > 0) {
         definitionMap.set('schemas', literalArr(meta.schemas.map((ref) => ref.value)));
     }
@@ -10495,19 +10510,18 @@ function transformExpressionsInExpression(expr, transform, flags) {
             expr.body = transformExpressionsInExpression(expr.body, transform, flags);
         }
     }
-    else if (expr instanceof WrappedNodeExpr) {
-        // TODO: Do we need to transform any TS nodes nested inside of this expression?
-    }
+    else if (expr instanceof WrappedNodeExpr) ;
     else if (expr instanceof TemplateLiteralExpr) {
         for (let i = 0; i < expr.expressions.length; i++) {
             expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform, flags);
         }
     }
+    else if (expr instanceof ParenthesizedExpr) {
+        expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
+    }
     else if (expr instanceof ReadVarExpr ||
         expr instanceof ExternalExpr ||
-        expr instanceof LiteralExpr) {
-        // No action for these types.
-    }
+        expr instanceof LiteralExpr) ;
     else {
         throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
     }
@@ -11577,6 +11591,33 @@ function assignI18nSlotDependencies(job) {
     }
 }
 
+/**
+ * Locates all of the elements defined in a creation block and outputs an op
+ * that will expose their definition location in the DOM.
+ */
+function attachSourceLocations(job) {
+    if (!job.enableDebugLocations || job.relativeTemplatePath === null) {
+        return;
+    }
+    for (const unit of job.units) {
+        const locations = [];
+        for (const op of unit.create) {
+            if (op.kind === OpKind.ElementStart || op.kind === OpKind.Element) {
+                const start = op.startSourceSpan.start;
+                locations.push({
+                    targetSlot: op.handle,
+                    offset: start.offset,
+                    line: start.line,
+                    column: start.col,
+                });
+            }
+        }
+        if (locations.length > 0) {
+            unit.create.push(createSourceLocationOp(job.relativeTemplatePath, locations));
+        }
+    }
+}
+
 /**
  * Gets a map of all elements in the given view by their xref id.
  */
@@ -12267,29 +12308,6 @@ function convertI18nBindings(job) {
     }
 }
 
-/**
- * Resolve the dependency function of a deferred block.
- */
-function resolveDeferDepsFns(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.Defer) {
-                if (op.resolverFn !== null) {
-                    continue;
-                }
-                if (op.ownResolverFn !== null) {
-                    if (op.handle.slot === null) {
-                        throw new Error('AssertionError: slot must be assigned before extracting defer deps functions');
-                    }
-                    const fullPathName = unit.fnName?.replace('_Template', '');
-                    op.resolverFn = job.pool.getSharedFunctionReference(op.ownResolverFn, `${fullPathName}_Defer_${op.handle.slot}_DepsFn`, 
-                    /* Don't use unique names for TDB compatibility */ false);
-                }
-            }
-        }
-    }
-}
-
 /**
  * Create one helper context op per i18n block (including generate descending blocks).
  *
@@ -12406,11 +12424,6 @@ function deduplicateTextBindings(job) {
                             OpList.remove(op);
                         }
                     }
-                    else {
-                        // TODO: Determine the correct behavior. It would probably make sense to merge multiple
-                        // style and class attributes. Alternatively we could just throw an error, as HTML
-                        // doesn't permit duplicate attributes.
-                    }
                 }
                 seenForElement.add(op.name);
                 seen.set(op.target, seenForElement);
@@ -12541,9 +12554,9 @@ function resolveDeferTargetNames(job) {
         }
     }
 }
-class Scope$1 {
+let Scope$1 = class Scope {
     targets = new Map();
-}
+};
 
 const REPLACEMENTS = new Map([
     [OpKind.ElementEnd, [OpKind.ElementStart, OpKind.Element]],
@@ -12599,14 +12612,6 @@ function expandSafeReads(job) {
         }
     }
 }
-// A lookup set of all the expression kinds that require a temporary variable to be generated.
-const requiresTemporary = [
-    InvokeFunctionExpr,
-    LiteralArrayExpr,
-    LiteralMapExpr,
-    SafeInvokeFunctionExpr,
-    PipeBindingExpr,
-].map((e) => e.constructor.name);
 function needsTemporaryInSafeAccess(e) {
     // TODO: We probably want to use an expression visitor to recursively visit all descendents.
     // However, that would potentially do a lot of extra work (because it cannot short circuit), so we
@@ -12634,6 +12639,9 @@ function needsTemporaryInSafeAccess(e) {
     else if (e instanceof ReadKeyExpr) {
         return needsTemporaryInSafeAccess(e.receiver) || needsTemporaryInSafeAccess(e.index);
     }
+    else if (e instanceof ParenthesizedExpr) {
+        return needsTemporaryInSafeAccess(e.expr);
+    }
     // TODO: Switch to a method which is exhaustive of newly added expression subtypes.
     return (e instanceof InvokeFunctionExpr ||
         e instanceof LiteralArrayExpr ||
@@ -12764,7 +12772,7 @@ function ternaryTransform(e) {
     if (!(e instanceof SafeTernaryExpr)) {
         return e;
     }
-    return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
+    return new ParenthesizedExpr(new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr));
 }
 
 /**
@@ -12878,7 +12886,7 @@ function createI18nMessage(job, context, messagePlaceholder) {
     let formattedParams = formatParams(context.params);
     const formattedPostprocessingParams = formatParams(context.postprocessingParams);
     let needsPostprocessing = [...context.params.values()].some((v) => v.length > 1);
-    return createI18nMessageOp(job.allocateXrefId(), context.xref, context.i18nBlock, context.message, messagePlaceholder ?? null, formattedParams, formattedPostprocessingParams, needsPostprocessing);
+    return createI18nMessageOp(job.allocateXrefId(), context.xref, context.i18nBlock, context.message, null, formattedParams, formattedPostprocessingParams, needsPostprocessing);
 }
 /**
  * Formats an ICU placeholder into a single string with expression placeholders.
@@ -13037,6 +13045,27 @@ function generateAdvance(job) {
     }
 }
 
+/**
+ * Replaces the `storeLet` ops with variables that can be
+ * used to reference the value within the same view.
+ */
+function generateLocalLetReferences(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            if (op.kind !== OpKind.StoreLet) {
+                continue;
+            }
+            const variable = {
+                kind: SemanticVariableKind.Identifier,
+                name: null,
+                identifier: op.declaredName,
+                local: true,
+            };
+            OpList.replace(op, createVariableOp(job.allocateXrefId(), variable, new StoreLetExpr(op.target, op.value, op.sourceSpan), VariableFlags.None));
+        }
+    }
+}
+
 /**
  * Locate projection slots, populate the each component's `ngContentSelectors` literal field,
  * populate `project` arguments, and generate the required `projectionDef` instruction for the job's
@@ -13329,9 +13358,6 @@ function parseProperty(name) {
     return { property, suffix };
 }
 
-function mapEntry(key, value) {
-    return { key, value, quoted: false };
-}
 function mapLiteral(obj, quoted = false) {
     return literalMap(Object.keys(obj).map((key) => ({
         key,
@@ -16951,7 +16977,7 @@ class ParseTreeResult {
         this.errors = errors;
     }
 }
-class Parser$1 {
+let Parser$1 = class Parser {
     getTagDefinition;
     constructor(getTagDefinition) {
         this.getTagDefinition = getTagDefinition;
@@ -16962,7 +16988,7 @@ class Parser$1 {
         parser.build();
         return new ParseTreeResult(parser.rootNodes, tokenizeResult.errors.concat(parser.errors));
     }
-}
+};
 class _TreeBuilder {
     tokens;
     getTagDefinition;
@@ -17643,9 +17669,6 @@ function transformTextToken({ type, parts, sourceSpan }, transform) {
 function processWhitespace(text) {
     return replaceNgsp(text).replace(WS_REPLACE_REGEXP, ' ');
 }
-function removeWhitespaces(htmlAstWithErrors, preserveSignificantWhitespace) {
-    return new ParseTreeResult(visitAllWithSiblings(new WhitespaceVisitor(preserveSignificantWhitespace), htmlAstWithErrors.rootNodes), htmlAstWithErrors.errors);
-}
 function visitAllWithSiblings(visitor, nodes) {
     const result = [];
     nodes.forEach((ast, i) => {
@@ -17998,9 +18021,7 @@ class _Scanner {
         let hasSeparators = false;
         this.advance(); // Skip initial digit.
         while (true) {
-            if (isDigit(this.peek)) {
-                // Do nothing.
-            }
+            if (isDigit(this.peek)) ;
             else if (this.peek === $_) {
                 // Separators are only valid when they're surrounded by digits. E.g. `1_0_1` is
                 // valid while `_101` and `101_` are not. The separator can't be next to the decimal
@@ -18474,7 +18495,6 @@ class _ParseAST {
     parseFlags;
     errors;
     offset;
-    lastUnary = null;
     rparensExpected = 0;
     rbracketsExpected = 0;
     rbracesExpected = 0;
@@ -18865,11 +18885,14 @@ class _ParseAST {
             // This aligns with Javascript semantics which require any unary operator preceeding the
             // exponentiation operation to be explicitly grouped as either applying to the base or result
             // of the exponentiation operation.
-            if (result === this.lastUnary) {
+            if (result instanceof Unary ||
+                result instanceof PrefixNot ||
+                result instanceof TypeofExpression ||
+                result instanceof VoidExpression) {
                 this.error('Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence');
             }
             this.advance();
-            const right = this.parsePrefix();
+            const right = this.parseExponentiation();
             result = new Binary(this.span(start), this.sourceSpan(start), '**', result, right);
         }
         return result;
@@ -18883,28 +18906,28 @@ class _ParseAST {
                 case '+':
                     this.advance();
                     result = this.parsePrefix();
-                    return (this.lastUnary = Unary.createPlus(this.span(start), this.sourceSpan(start), result));
+                    return Unary.createPlus(this.span(start), this.sourceSpan(start), result);
                 case '-':
                     this.advance();
                     result = this.parsePrefix();
-                    return (this.lastUnary = Unary.createMinus(this.span(start), this.sourceSpan(start), result));
+                    return Unary.createMinus(this.span(start), this.sourceSpan(start), result);
                 case '!':
                     this.advance();
                     result = this.parsePrefix();
-                    return (this.lastUnary = new PrefixNot(this.span(start), this.sourceSpan(start), result));
+                    return new PrefixNot(this.span(start), this.sourceSpan(start), result);
             }
         }
         else if (this.next.isKeywordTypeof()) {
             this.advance();
             const start = this.inputIndex;
             let result = this.parsePrefix();
-            return (this.lastUnary = new TypeofExpression(this.span(start), this.sourceSpan(start), result));
+            return new TypeofExpression(this.span(start), this.sourceSpan(start), result);
         }
         else if (this.next.isKeywordVoid()) {
             this.advance();
             const start = this.inputIndex;
             let result = this.parsePrefix();
-            return (this.lastUnary = new VoidExpression(this.span(start), this.sourceSpan(start), result));
+            return new VoidExpression(this.span(start), this.sourceSpan(start), result);
         }
         return this.parseCallChain();
     }
@@ -18934,6 +18957,12 @@ class _ParseAST {
             else if (this.consumeOptionalOperator('!')) {
                 result = new NonNullAssert(this.span(start), this.sourceSpan(start), result);
             }
+            else if (this.next.isTemplateLiteralEnd()) {
+                result = this.parseNoInterpolationTaggedTemplateLiteral(result, start);
+            }
+            else if (this.next.isTemplateLiteralPart()) {
+                result = this.parseTaggedTemplateLiteral(result, start);
+            }
             else {
                 return result;
             }
@@ -18945,9 +18974,8 @@ class _ParseAST {
             this.rparensExpected++;
             const result = this.parsePipe();
             this.rparensExpected--;
-            this.lastUnary = null;
             this.expectCharacter($RPAREN);
-            return result;
+            return new ParenthesizedExpression(this.span(start), this.sourceSpan(start), result);
         }
         else if (this.next.isKeywordNull()) {
             this.advance();
@@ -18988,7 +19016,7 @@ class _ParseAST {
             return new LiteralPrimitive(this.span(start), this.sourceSpan(start), value);
         }
         else if (this.next.isTemplateLiteralEnd()) {
-            return this.parseNoInterpolationTemplateLiteral(start);
+            return this.parseNoInterpolationTemplateLiteral();
         }
         else if (this.next.isTemplateLiteralPart()) {
             return this.parseTemplateLiteral();
@@ -19318,22 +19346,32 @@ class _ParseAST {
         const sourceSpan = new AbsoluteSourceSpan(spanStart, this.currentAbsoluteOffset);
         return new VariableBinding(sourceSpan, key, value);
     }
-    parseNoInterpolationTemplateLiteral(start) {
+    parseNoInterpolationTaggedTemplateLiteral(tag, start) {
+        const template = this.parseNoInterpolationTemplateLiteral();
+        return new TaggedTemplateLiteral(this.span(start), this.sourceSpan(start), tag, template);
+    }
+    parseNoInterpolationTemplateLiteral() {
         const text = this.next.strValue;
+        const start = this.inputIndex;
         this.advance();
         const span = this.span(start);
         const sourceSpan = this.sourceSpan(start);
         return new TemplateLiteral(span, sourceSpan, [new TemplateLiteralElement(span, sourceSpan, text)], []);
     }
+    parseTaggedTemplateLiteral(tag, start) {
+        const template = this.parseTemplateLiteral();
+        return new TaggedTemplateLiteral(this.span(start), this.sourceSpan(start), tag, template);
+    }
     parseTemplateLiteral() {
-        const start = this.inputIndex;
         const elements = [];
         const expressions = [];
+        const start = this.inputIndex;
         while (this.next !== EOF) {
             const token = this.next;
             if (token.isTemplateLiteralPart() || token.isTemplateLiteralEnd()) {
-                elements.push(new TemplateLiteralElement(this.span(this.inputIndex), this.sourceSpan(this.inputIndex), token.strValue));
+                const partStart = this.inputIndex;
                 this.advance();
+                elements.push(new TemplateLiteralElement(this.span(partStart), this.sourceSpan(partStart), token.strValue));
                 if (token.isTemplateLiteralEnd()) {
                     break;
                 }
@@ -19589,6 +19627,12 @@ class SerializeExpressionVisitor {
     visitTemplateLiteralElement(ast, context) {
         return ast.text;
     }
+    visitTaggedTemplateLiteral(ast, context) {
+        return ast.tag.visit(this, context) + ast.template.visit(this, context);
+    }
+    visitParenthesizedExpression(ast, context) {
+        return '(' + ast.expression.visit(this, context) + ')';
+    }
 }
 /** Zips the two input arrays into a single array of pairs of elements at the same index. */
 function zip(left, right) {
@@ -22138,30 +22182,6 @@ function disableBindings$1(job) {
     }
 }
 
-/**
- * Nullish coalescing expressions such as `a ?? b` have different semantics in Angular templates as
- * compared to JavaScript. In particular, they default to `null` instead of `undefined`. Therefore,
- * we replace them with ternary expressions, assigning temporaries as needed to avoid re-evaluating
- * the same sub-expression multiple times.
- */
-function generateNullishCoalesceExpressions(job) {
-    for (const unit of job.units) {
-        for (const op of unit.ops()) {
-            transformExpressionsInOp(op, (expr) => {
-                if (!(expr instanceof BinaryOperatorExpr) ||
-                    expr.operator !== BinaryOperator.NullishCoalesce) {
-                    return expr;
-                }
-                const assignment = new AssignTemporaryExpr(expr.lhs.clone(), job.allocateXrefId());
-                const read = new ReadTemporaryExpr(assignment.xref);
-                // TODO: When not in compatibility mode for TemplateDefinitionBuilder, we can just emit
-                // `t != null` instead of including an undefined check as well.
-                return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, assignment, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, read, new LiteralExpr(undefined))), read.clone(), expr.rhs);
-            }, VisitorContextFlag.None);
-        }
-    }
-}
-
 function kindTest(kind) {
     return (op) => op.kind === kind;
 }
@@ -23164,7 +23184,17 @@ const PURE_FUNCTION_CONFIG = {
     mapping: (n) => n,
 };
 function callVariadicInstructionExpr(config, baseArgs, interpolationArgs, extraArgs, sourceSpan) {
+    // mapping need to be done before potentially dropping the last interpolation argument
     const n = config.mapping(interpolationArgs.length);
+    // In the case the interpolation instruction ends with a empty string we drop it
+    // And the runtime will take care of it.
+    const lastInterpolationArg = interpolationArgs.at(-1);
+    if (extraArgs.length === 0 &&
+        interpolationArgs.length > 1 &&
+        lastInterpolationArg instanceof LiteralExpr &&
+        lastInterpolationArg.value === '') {
+        interpolationArgs.pop();
+    }
     if (n < config.constant.length) {
         // Constant calling pattern.
         return importExpr(config.constant[n])
@@ -23205,31 +23235,6 @@ function reify(job) {
         reifyUpdateOperations(unit, unit.update);
     }
 }
-/**
- * This function can be used a sanity check -- it walks every expression in the const pool, and
- * every expression reachable from an op, and makes sure that there are no IR expressions
- * left. This is nice to use for debugging mysterious failures where an IR expression cannot be
- * output from the output AST code.
- */
-function ensureNoIrForDebug(job) {
-    for (const stmt of job.pool.statements) {
-        transformExpressionsInStatement(stmt, (expr) => {
-            if (isIrExpression(expr)) {
-                throw new Error(`AssertionError: IR expression found during reify: ${ExpressionKind[expr.kind]}`);
-            }
-            return expr;
-        }, VisitorContextFlag.None);
-    }
-    for (const unit of job.units) {
-        for (const op of unit.ops()) {
-            visitExpressionsInOp(op, (expr) => {
-                if (isIrExpression(expr)) {
-                    throw new Error(`AssertionError: IR expression found during reify: ${ExpressionKind[expr.kind]}`);
-                }
-            });
-        }
-    }
-}
 function reifyCreateOperations(unit, ops) {
     for (const op of ops) {
         transformExpressionsInOp(op, reifyIrExpression, VisitorContextFlag.None);
@@ -23705,6 +23710,33 @@ function removeI18nContexts(job) {
     }
 }
 
+/**
+ * It's not allowed to access a `@let` declaration before it has been defined. This is enforced
+ * already via template type checking, however it can trip some of the assertions in the pipeline.
+ * E.g. the naming phase can fail because we resolved the variable here, but the variable doesn't
+ * exist anymore because the optimization phase removed it since it's invalid. To avoid surfacing
+ * confusing errors to users in the case where template type checking isn't running (e.g. in JIT
+ * mode) this phase detects illegal forward references and replaces them with `undefined`.
+ * Eventually users will see the proper error from the template type checker.
+ */
+function removeIllegalLetReferences(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            if (op.kind !== OpKind.Variable ||
+                op.variable.kind !== SemanticVariableKind.Identifier ||
+                !(op.initializer instanceof StoreLetExpr)) {
+                continue;
+            }
+            const name = op.variable.identifier;
+            let current = op;
+            while (current && current.kind !== OpKind.ListEnd) {
+                transformExpressionsInOp(current, (expr) => expr instanceof LexicalReadExpr && expr.name === name ? literal(undefined) : expr, VisitorContextFlag.None);
+                current = current.prev;
+            }
+        }
+    }
+}
+
 /**
  * i18nAttributes ops will be generated for each i18n attribute. However, not all i18n attribues
  * will contain dynamic content, and so some of these i18nAttributes ops may be unnecessary.
@@ -23786,6 +23818,29 @@ function processLexicalScope$1(view, ops) {
     }
 }
 
+/**
+ * Resolve the dependency function of a deferred block.
+ */
+function resolveDeferDepsFns(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.Defer) {
+                if (op.resolverFn !== null) {
+                    continue;
+                }
+                if (op.ownResolverFn !== null) {
+                    if (op.handle.slot === null) {
+                        throw new Error('AssertionError: slot must be assigned before extracting defer deps functions');
+                    }
+                    const fullPathName = unit.fnName?.replace('_Template', '');
+                    op.resolverFn = job.pool.getSharedFunctionReference(op.ownResolverFn, `${fullPathName}_Defer_${op.handle.slot}_DepsFn`, 
+                    /* Don't use unique names for TDB compatibility */ false);
+                }
+            }
+        }
+    }
+}
+
 /**
  * Any variable inside a listener with the name `$event` will be transformed into a output lexical
  * read immediately, and does not participate in any of the normal logic for handling variables.
@@ -24362,39 +24417,6 @@ function getOnlySecurityContext(securityContext) {
     return securityContext;
 }
 
-/**
- * Transforms a `TwoWayBindingSet` expression into an expression that either
- * sets a value through the `twoWayBindingSet` instruction or falls back to setting
- * the value directly. E.g. the expression `TwoWayBindingSet(target, value)` becomes:
- * `ng.twoWayBindingSet(target, value) || (target = value)`.
- */
-function transformTwoWayBindingSet(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.TwoWayListener) {
-                transformExpressionsInOp(op, (expr) => {
-                    if (!(expr instanceof TwoWayBindingSetExpr)) {
-                        return expr;
-                    }
-                    const { target, value } = expr;
-                    if (target instanceof ReadPropExpr || target instanceof ReadKeyExpr) {
-                        return twoWayBindingSet(target, value).or(target.set(value));
-                    }
-                    // ASSUMPTION: here we're assuming that `ReadVariableExpr` will be a reference
-                    // to a local template variable. This appears to be the case at the time of writing.
-                    // If the expression is targeting a variable read, we only emit the `twoWayBindingSet`
-                    // since the fallback would be attempting to write into a constant. Invalid usages will be
-                    // flagged during template type checking.
-                    if (target instanceof ReadVariableExpr) {
-                        return twoWayBindingSet(target, value);
-                    }
-                    throw new Error(`Unsupported expression in two-way action binding.`);
-                }, VisitorContextFlag.InChildOperation);
-            }
-        }
-    }
-}
-
 /**
  * When inside of a listener, we may need access to one or more enclosing views. Therefore, each
  * view should save the current view, and each listener must have the ability to restore the
@@ -24504,6 +24526,107 @@ function allocateSlots(job) {
     }
 }
 
+/*!
+ * @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.dev/license
+ */
+/**
+ * Removes any `storeLet` calls that aren't referenced outside of the current view.
+ */
+function optimizeStoreLet(job) {
+    const letUsedExternally = new Set();
+    // Since `@let` declarations can be referenced in child views, both in
+    // the creation block (via listeners) and in the update block, we have
+    // to look through all the ops to find the references.
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            visitExpressionsInOp(op, (expr) => {
+                if (expr instanceof ContextLetReferenceExpr) {
+                    letUsedExternally.add(expr.target);
+                }
+            });
+        }
+    }
+    // TODO(crisbeto): potentially remove the unused calls completely, pending discussion.
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            transformExpressionsInOp(op, (expression) => expression instanceof StoreLetExpr && !letUsedExternally.has(expression.target)
+                ? expression.value
+                : expression, VisitorContextFlag.None);
+        }
+    }
+}
+
+/**
+ * In most cases we can drop user added parentheses from expressions. However, in some cases
+ * parentheses are needed for the expression to be considered valid JavaScript or for Typescript to
+ * generate the correct output. This phases strips all parentheses except in the following
+ * siturations where they are required:
+ *
+ * 1. Unary operators in the base of an exponentiation expression. For example, `-2 ** 3` is not
+ *    valid JavaScript, but `(-2) ** 3` is.
+ * 2. When mixing nullish coalescing (`??`) and logical and/or operators (`&&`, `||`), we need
+ *    parentheses. For example, `a ?? b && c` is not valid JavaScript, but `a ?? (b && c)` is.
+ * 3. Ternary expression used as an operand for nullish coalescing. Typescript generates incorrect
+ *    code if the parentheses are missing. For example when `(a ? b : c) ?? d` is translated to
+ *    typescript AST, the parentheses node is removed, and then the remaining AST is printed, it
+ *    incorrectly prints `a ? b : c ?? d`. This is different from how it handles the same situation
+ *    with `||` and `&&` where it prints the parentheses even if they are not present in the AST.
+ */
+function stripNonrequiredParentheses(job) {
+    // Check which parentheses are required.
+    const requiredParens = new Set();
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            visitExpressionsInOp(op, (expr) => {
+                if (expr instanceof BinaryOperatorExpr) {
+                    switch (expr.operator) {
+                        case BinaryOperator.Exponentiation:
+                            checkExponentiationParens(expr, requiredParens);
+                            break;
+                        case BinaryOperator.NullishCoalesce:
+                            checkNullishCoalescingParens(expr, requiredParens);
+                            break;
+                    }
+                }
+            });
+        }
+    }
+    // Remove any non-required parentheses.
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            transformExpressionsInOp(op, (expr) => {
+                if (expr instanceof ParenthesizedExpr) {
+                    return requiredParens.has(expr) ? expr : expr.expr;
+                }
+                return expr;
+            }, VisitorContextFlag.None);
+        }
+    }
+}
+function checkExponentiationParens(expr, requiredParens) {
+    if (expr.lhs instanceof ParenthesizedExpr && expr.lhs.expr instanceof UnaryOperatorExpr) {
+        requiredParens.add(expr.lhs);
+    }
+}
+function checkNullishCoalescingParens(expr, requiredParens) {
+    if (expr.lhs instanceof ParenthesizedExpr &&
+        (isLogicalAndOr(expr.lhs.expr) || expr.lhs.expr instanceof ConditionalExpr)) {
+        requiredParens.add(expr.lhs);
+    }
+    if (expr.rhs instanceof ParenthesizedExpr &&
+        (isLogicalAndOr(expr.rhs.expr) || expr.rhs.expr instanceof ConditionalExpr)) {
+        requiredParens.add(expr.rhs);
+    }
+}
+function isLogicalAndOr(expr) {
+    return (expr instanceof BinaryOperatorExpr &&
+        (expr.operator === BinaryOperator.And || expr.operator === BinaryOperator.Or));
+}
+
 /**
  * Transforms special-case bindings with 'style' or 'class' in their names. Must run before the
  * main binding specialization pass.
@@ -24731,6 +24854,39 @@ function generateTrackVariables(job) {
     }
 }
 
+/**
+ * Transforms a `TwoWayBindingSet` expression into an expression that either
+ * sets a value through the `twoWayBindingSet` instruction or falls back to setting
+ * the value directly. E.g. the expression `TwoWayBindingSet(target, value)` becomes:
+ * `ng.twoWayBindingSet(target, value) || (target = value)`.
+ */
+function transformTwoWayBindingSet(job) {
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.TwoWayListener) {
+                transformExpressionsInOp(op, (expr) => {
+                    if (!(expr instanceof TwoWayBindingSetExpr)) {
+                        return expr;
+                    }
+                    const { target, value } = expr;
+                    if (target instanceof ReadPropExpr || target instanceof ReadKeyExpr) {
+                        return twoWayBindingSet(target, value).or(target.set(value));
+                    }
+                    // ASSUMPTION: here we're assuming that `ReadVariableExpr` will be a reference
+                    // to a local template variable. This appears to be the case at the time of writing.
+                    // If the expression is targeting a variable read, we only emit the `twoWayBindingSet`
+                    // since the fallback would be attempting to write into a constant. Invalid usages will be
+                    // flagged during template type checking.
+                    if (target instanceof ReadVariableExpr) {
+                        return twoWayBindingSet(target, value);
+                    }
+                    throw new Error(`Unsupported expression in two-way action binding.`);
+                }, VisitorContextFlag.InChildOperation);
+            }
+        }
+    }
+}
+
 /**
  * Counts the number of variable slots used within each view, and stores that on the view itself, as
  * well as propagates it to the `ir.TemplateOp` for embedded views.
@@ -25330,115 +25486,6 @@ function wrapI18nIcus(job) {
     }
 }
 
-/*!
- * @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.dev/license
- */
-/**
- * Removes any `storeLet` calls that aren't referenced outside of the current view.
- */
-function optimizeStoreLet(job) {
-    const letUsedExternally = new Set();
-    // Since `@let` declarations can be referenced in child views, both in
-    // the creation block (via listeners) and in the update block, we have
-    // to look through all the ops to find the references.
-    for (const unit of job.units) {
-        for (const op of unit.ops()) {
-            visitExpressionsInOp(op, (expr) => {
-                if (expr instanceof ContextLetReferenceExpr) {
-                    letUsedExternally.add(expr.target);
-                }
-            });
-        }
-    }
-    // TODO(crisbeto): potentially remove the unused calls completely, pending discussion.
-    for (const unit of job.units) {
-        for (const op of unit.update) {
-            transformExpressionsInOp(op, (expression) => expression instanceof StoreLetExpr && !letUsedExternally.has(expression.target)
-                ? expression.value
-                : expression, VisitorContextFlag.None);
-        }
-    }
-}
-
-/**
- * It's not allowed to access a `@let` declaration before it has been defined. This is enforced
- * already via template type checking, however it can trip some of the assertions in the pipeline.
- * E.g. the naming phase can fail because we resolved the variable here, but the variable doesn't
- * exist anymore because the optimization phase removed it since it's invalid. To avoid surfacing
- * confusing errors to users in the case where template type checking isn't running (e.g. in JIT
- * mode) this phase detects illegal forward references and replaces them with `undefined`.
- * Eventually users will see the proper error from the template type checker.
- */
-function removeIllegalLetReferences(job) {
-    for (const unit of job.units) {
-        for (const op of unit.update) {
-            if (op.kind !== OpKind.Variable ||
-                op.variable.kind !== SemanticVariableKind.Identifier ||
-                !(op.initializer instanceof StoreLetExpr)) {
-                continue;
-            }
-            const name = op.variable.identifier;
-            let current = op;
-            while (current && current.kind !== OpKind.ListEnd) {
-                transformExpressionsInOp(current, (expr) => expr instanceof LexicalReadExpr && expr.name === name ? literal(undefined) : expr, VisitorContextFlag.None);
-                current = current.prev;
-            }
-        }
-    }
-}
-
-/**
- * Replaces the `storeLet` ops with variables that can be
- * used to reference the value within the same view.
- */
-function generateLocalLetReferences(job) {
-    for (const unit of job.units) {
-        for (const op of unit.update) {
-            if (op.kind !== OpKind.StoreLet) {
-                continue;
-            }
-            const variable = {
-                kind: SemanticVariableKind.Identifier,
-                name: null,
-                identifier: op.declaredName,
-                local: true,
-            };
-            OpList.replace(op, createVariableOp(job.allocateXrefId(), variable, new StoreLetExpr(op.target, op.value, op.sourceSpan), VariableFlags.None));
-        }
-    }
-}
-
-/**
- * Locates all of the elements defined in a creation block and outputs an op
- * that will expose their definition location in the DOM.
- */
-function attachSourceLocations(job) {
-    if (!job.enableDebugLocations || job.relativeTemplatePath === null) {
-        return;
-    }
-    for (const unit of job.units) {
-        const locations = [];
-        for (const op of unit.create) {
-            if (op.kind === OpKind.ElementStart || op.kind === OpKind.Element) {
-                const start = op.startSourceSpan.start;
-                locations.push({
-                    targetSlot: op.handle,
-                    offset: start.offset,
-                    line: start.line,
-                    column: start.col,
-                });
-            }
-        }
-        if (locations.length > 0) {
-            unit.create.push(createSourceLocationOp(job.relativeTemplatePath, locations));
-        }
-    }
-}
-
 /**
  *
  * @license
@@ -25487,8 +25534,8 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: resolveContexts },
     { kind: CompilationJobKind.Both, fn: resolveSanitizers },
     { kind: CompilationJobKind.Tmpl, fn: liftLocalRefs },
-    { kind: CompilationJobKind.Both, fn: generateNullishCoalesceExpressions },
     { kind: CompilationJobKind.Both, fn: expandSafeReads },
+    { kind: CompilationJobKind.Both, fn: stripNonrequiredParentheses },
     { kind: CompilationJobKind.Both, fn: generateTemporaryVariables },
     { kind: CompilationJobKind.Both, fn: optimizeVariables },
     { kind: CompilationJobKind.Both, fn: optimizeStoreLet },
@@ -26282,21 +26329,30 @@ function convertAst(ast, job, baseSourceSpan) {
         return new VoidExpr(convertAst(ast.expression, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
     }
     else if (ast instanceof TemplateLiteral) {
-        return new TemplateLiteralExpr(ast.elements.map((el) => {
-            return new TemplateLiteralElementExpr(el.text, convertSourceSpan(el.span, baseSourceSpan));
-        }), ast.expressions.map((expr) => convertAst(expr, job, baseSourceSpan)), convertSourceSpan(ast.span, baseSourceSpan));
+        return convertTemplateLiteral(ast, job, baseSourceSpan);
+    }
+    else if (ast instanceof TaggedTemplateLiteral) {
+        return new TaggedTemplateLiteralExpr(convertAst(ast.tag, job, baseSourceSpan), convertTemplateLiteral(ast.template, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
+    }
+    else if (ast instanceof ParenthesizedExpression) {
+        return new ParenthesizedExpr(convertAst(ast.expression, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
     }
     else {
         throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
     }
 }
+function convertTemplateLiteral(ast, job, baseSourceSpan) {
+    return new TemplateLiteralExpr(ast.elements.map((el) => {
+        return new TemplateLiteralElementExpr(el.text, convertSourceSpan(el.span, baseSourceSpan));
+    }), ast.expressions.map((expr) => convertAst(expr, job, baseSourceSpan)), convertSourceSpan(ast.span, baseSourceSpan));
+}
 function convertAstWithInterpolation(job, value, i18nMeta, sourceSpan) {
     let expression;
     if (value instanceof Interpolation$1) {
-        expression = new Interpolation(value.strings, value.expressions.map((e) => convertAst(e, job, sourceSpan ?? null)), Object.keys(asMessage(i18nMeta)?.placeholders ?? {}));
+        expression = new Interpolation(value.strings, value.expressions.map((e) => convertAst(e, job, null)), Object.keys(asMessage(i18nMeta)?.placeholders ?? {}));
     }
     else if (value instanceof AST) {
-        expression = convertAst(value, job, sourceSpan ?? null);
+        expression = convertAst(value, job, null);
     }
     else {
         expression = literal(value);
@@ -26674,12 +26730,6 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
  * internal tooling as well.
  */
 let ENABLE_TEMPLATE_SOURCE_LOCATIONS = false;
-/**
- * Utility function to enable source locations. Intended to be used **only** inside unit tests.
- */
-function setEnableTemplateSourceLocations(value) {
-    ENABLE_TEMPLATE_SOURCE_LOCATIONS = value;
-}
 /** Gets whether template source locations are enabled. */
 function getTemplateSourceLocationsEnabled() {
     return ENABLE_TEMPLATE_SOURCE_LOCATIONS;
@@ -26687,7 +26737,7 @@ function getTemplateSourceLocationsEnabled() {
 
 //  if (rf & flags) { .. }
 function renderFlagCheckIfStmt(flags, statements) {
-    return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal(flags), null, false), statements);
+    return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal(flags), null), statements);
 }
 /**
  * Translates query flags into `TQueryFlags` type in
@@ -27276,15 +27326,6 @@ class BindingParser {
         return false;
     }
 }
-class PipeCollector extends RecursiveAstVisitor {
-    pipes = new Map();
-    visitPipe(ast, context) {
-        this.pipes.set(ast.name, ast);
-        ast.exp.visit(this);
-        this.visitAll(ast.args, context);
-        return null;
-    }
-}
 function isAnimationLabel(name) {
     return name[0] == '@';
 }
@@ -29621,23 +29662,35 @@ class R3TargetBinder {
      */
     bind(target) {
         if (!target.template) {
-            // TODO(alxhub): handle targets which contain things like HostBindings, etc.
-            throw new Error('Binding without a template not yet supported');
-        }
-        // First, parse the template into a `Scope` structure. This operation captures the syntactic
-        // scopes in the template and makes them available for later use.
-        const scope = Scope.apply(target.template);
-        // Use the `Scope` to extract the entities present at every level of the template.
-        const scopedNodeEntities = extractScopedNodeEntities(scope);
-        // Next, perform directive matching on the template using the `DirectiveBinder`. This returns:
-        //   - directives: Map of nodes (elements & ng-templates) to the directives on them.
-        //   - bindings: Map of inputs, outputs, and attributes to the directive/element that claims
-        //     them. TODO(alxhub): handle multiple directives claiming an input/output/etc.
-        //   - references: Map of #references to their targets.
-        const { directives, eagerDirectives, bindings, references } = DirectiveBinder.apply(target.template, this.directiveMatcher);
-        // Finally, run the TemplateBinder to bind references, variables, and other entities within the
-        // template. This extracts all the metadata that doesn't depend on directive matching.
-        const { expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks } = TemplateBinder.applyWithScope(target.template, scope);
+            throw new Error('Empty bound targets are not supported');
+        }
+        const directives = new Map();
+        const eagerDirectives = [];
+        const bindings = new Map();
+        const references = new Map();
+        const scopedNodeEntities = new Map();
+        const expressions = new Map();
+        const symbols = new Map();
+        const nestingLevel = new Map();
+        const usedPipes = new Set();
+        const eagerPipes = new Set();
+        const deferBlocks = [];
+        if (target.template) {
+            // First, parse the template into a `Scope` structure. This operation captures the syntactic
+            // scopes in the template and makes them available for later use.
+            const scope = Scope.apply(target.template);
+            // Use the `Scope` to extract the entities present at every level of the template.
+            extractScopedNodeEntities(scope, scopedNodeEntities);
+            // Next, perform directive matching on the template using the `DirectiveBinder`. This returns:
+            //   - directives: Map of nodes (elements & ng-templates) to the directives on them.
+            //   - bindings: Map of inputs, outputs, and attributes to the directive/element that claims
+            //     them. TODO(alxhub): handle multiple directives claiming an input/output/etc.
+            //   - references: Map of #references to their targets.
+            DirectiveBinder.apply(target.template, this.directiveMatcher, directives, eagerDirectives, bindings, references);
+            // Finally, run the TemplateBinder to bind references, variables, and other entities within the
+            // template. This extracts all the metadata that doesn't depend on directive matching.
+            TemplateBinder.applyWithScope(target.template, scope, expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks);
+        }
         return new R3BoundTarget(target, directives, eagerDirectives, bindings, references, expressions, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks);
     }
 }
@@ -29864,14 +29917,9 @@ class DirectiveBinder {
      * map which resolves #references (`Reference`s) within the template to the named directive or
      * template node.
      */
-    static apply(template, selectorMatcher) {
-        const directives = new Map();
-        const bindings = new Map();
-        const references = new Map();
-        const eagerDirectives = [];
+    static apply(template, selectorMatcher, directives, eagerDirectives, bindings, references) {
         const matcher = new DirectiveBinder(selectorMatcher, directives, eagerDirectives, bindings, references);
         matcher.ingest(template);
-        return { directives, eagerDirectives, bindings, references };
     }
     ingest(template) {
         template.forEach((node) => node.visit(this));
@@ -30056,18 +30104,11 @@ class TemplateBinder extends RecursiveAstVisitor {
      * nesting level (how many levels deep within the template structure the `Template` is), starting
      * at 1.
      */
-    static applyWithScope(nodes, scope) {
-        const expressions = new Map();
-        const symbols = new Map();
-        const nestingLevel = new Map();
-        const usedPipes = new Set();
-        const eagerPipes = new Set();
+    static applyWithScope(nodes, scope, expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks) {
         const template = nodes instanceof Template ? nodes : null;
-        const deferBlocks = [];
         // The top-level template has nesting level 0.
         const binder = new TemplateBinder(expressions, symbols, usedPipes, eagerPipes, deferBlocks, nestingLevel, scope, template, 0);
         binder.ingest(nodes);
-        return { expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks };
     }
     ingest(nodeOrNodes) {
         if (nodeOrNodes instanceof Template) {
@@ -30417,7 +30458,7 @@ class R3BoundTarget {
         return this.referenceTargetToElement(target.node);
     }
 }
-function extractScopedNodeEntities(rootScope) {
+function extractScopedNodeEntities(rootScope, templateEntities) {
     const entityMap = new Map();
     function extractScopeEntities(scope) {
         if (entityMap.has(scope.rootNode)) {
@@ -30442,11 +30483,9 @@ function extractScopedNodeEntities(rootScope) {
         }
         extractScopeEntities(scope);
     }
-    const templateEntities = new Map();
     for (const [template, entities] of entityMap) {
         templateEntities.set(template, new Set(entities.values()));
     }
-    return templateEntities;
 }
 
 /**
@@ -30469,10 +30508,8 @@ class CompilerFacadeImpl {
     }
     compilePipe(angularCoreEnv, sourceMapUrl, facade) {
         const metadata = {
-            name: facade.name,
             type: wrapReference(facade.type),
             typeArgumentCount: 0,
-            deps: null,
             pipeName: facade.pipeName,
             pure: facade.pure,
             isStandalone: facade.isStandalone,
@@ -30517,7 +30554,6 @@ class CompilerFacadeImpl {
     }
     compileInjector(angularCoreEnv, sourceMapUrl, facade) {
         const meta = {
-            name: facade.name,
             type: wrapReference(facade.type),
             providers: facade.providers && facade.providers.length > 0
                 ? new WrappedNodeExpr(facade.providers)
@@ -31716,7 +31752,7 @@ class Xliff extends Serializer {
         return digest$1(message);
     }
 }
-class _WriteVisitor$1 {
+let _WriteVisitor$1 = class _WriteVisitor {
     visitText(text, context) {
         return [new Text$1(text.value)];
     }
@@ -31775,7 +31811,7 @@ class _WriteVisitor$1 {
     serialize(nodes) {
         return [].concat(...nodes.map((node) => node.visit(this)));
     }
-}
+};
 // TODO(vicb): add error management (structure)
 // Extract messages as xml nodes from the xliff file
 class XliffParser {
@@ -31858,7 +31894,7 @@ class XliffParser {
     }
 }
 // Convert ml nodes (xliff syntax) to i18n nodes
-class XmlToI18n$2 {
+let XmlToI18n$2 = class XmlToI18n {
     // using non-null assertion because it's re(set) by convert()
     _errors;
     convert(message, url) {
@@ -31911,7 +31947,7 @@ class XmlToI18n$2 {
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
-}
+};
 function getCtypeForTag(tag) {
     switch (tag.toLowerCase()) {
         case 'br':
@@ -32173,7 +32209,7 @@ class Xliff2Parser {
     }
 }
 // Convert ml nodes (xliff syntax) to i18n nodes
-class XmlToI18n$1 {
+let XmlToI18n$1 = class XmlToI18n {
     // using non-null assertion because re(set) by convert()
     _errors;
     convert(message, url) {
@@ -32243,7 +32279,7 @@ class XmlToI18n$1 {
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
-}
+};
 function getTypeForTag(tag) {
     switch (tag.toLowerCase()) {
         case 'br':
@@ -32845,7 +32881,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -32863,7 +32899,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? literal(null));
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', literal('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -32958,7 +32994,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -33059,9 +33095,6 @@ function compileQuery(query) {
         // Therefore we explicitly emit the field, and explicitly place it only when it's `false`.
         meta.set('emitDistinctChangesOnly', literal(false));
     }
-    else {
-        // The linker will assume that an absent `emitDistinctChangesOnly` flag is by default `true`.
-    }
     if (query.descendants) {
         meta.set('descendants', literal(true));
     }
@@ -33377,7 +33410,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('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -33412,7 +33445,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -33463,7 +33496,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -33496,7 +33529,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('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     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.
@@ -33547,7 +33580,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('20.0.0-next.0'));
+    definitionMap.set('version', literal('20.0.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -33705,24 +33738,31 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('20.0.0-next.0');
+const VERSION = new Version('20.0.0-next.2');
 
 //////////////////////////////////////
-// This file only reexports content of the `src` folder. Keep it that way.
-// This function call has a global side effects and publishes the compiler into global namespace for
-// the late binding of the Compiler to the @angular/core for jit compilation.
-publishFacade(_global);
-
+// THIS FILE HAS GLOBAL SIDE EFFECT //
+//       (see bottom of file)       //
+//////////////////////////////////////
 /**
  * @module
  * @description
- * Entry point for all public APIs of this package.
+ * Entry point for all APIs of the compiler package.
+ *
+ * <div class="callout is-critical">
+ *   <header>Unstable APIs</header>
+ *   <p>
+ *     All compiler apis are currently considered experimental and private!
+ *   </p>
+ *   <p>
+ *     We expect the APIs in this package to keep on changing. Do not rely on them.
+ *   </p>
+ * </div>
  */
 // This file only reexports content of the `src` folder. Keep it that way.
+// This function call has a global side effects and publishes the compiler into global namespace for
+// the late binding of the Compiler to the @angular/core for jit compilation.
+publishFacade(_global);
 
-// This file is not used to build this module. It is only used during editing
-
-// This file is not used to build this module. It is only used during editing
-
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingType, 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, LetDeclaration, 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, ParsedEventType, ParsedProperty, ParsedPropertyType, ParsedVariable, 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, StringToken, StringTokenKind, TagContentType, TaggedTemplateLiteralExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, TemplateLiteralElementExpr, TemplateLiteralExpr, Text, ThisReceiver, BlockNode as TmplAstBlockNode, 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, LetDeclaration$1 as TmplAstLetDeclaration, NeverDeferredTrigger as TmplAstNeverDeferredTrigger, 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, TypeofExpression, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDeferResolverFunction, compileDirectiveFromMetadata, compileFactoryFunction, compileHmrInitializer, compileHmrUpdateCallback, compileInjectable, compileInjector, compileNgModule, compileOpaqueAsyncClassMetadata, compilePipeFromMetadata, computeMsgId, core, createCssSelectorFromNode, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, encapsulateStyle, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingType, 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, LetDeclaration, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParenthesizedExpr, ParenthesizedExpression, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedEventType, ParsedProperty, ParsedPropertyType, ParsedVariable, 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, StringToken, StringTokenKind, TagContentType, TaggedTemplateLiteral, TaggedTemplateLiteralExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, TemplateLiteralElementExpr, TemplateLiteralExpr, Text, ThisReceiver, BlockNode as TmplAstBlockNode, 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, LetDeclaration$1 as TmplAstLetDeclaration, NeverDeferredTrigger as TmplAstNeverDeferredTrigger, 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, TypeofExpression, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDeferResolverFunction, compileDirectiveFromMetadata, compileFactoryFunction, compileHmrInitializer, compileHmrUpdateCallback, compileInjectable, compileInjector, compileNgModule, compileOpaqueAsyncClassMetadata, compilePipeFromMetadata, computeMsgId, core, createCssSelectorFromNode, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, encapsulateStyle, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map