@angular/compiler 20.1.0-next.2 → 20.1.0-rc.0

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v20.1.0-next.2
+ * @license Angular v20.1.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -961,6 +961,15 @@ var BinaryOperator;
     BinaryOperator[BinaryOperator["NullishCoalesce"] = 18] = "NullishCoalesce";
     BinaryOperator[BinaryOperator["Exponentiation"] = 19] = "Exponentiation";
     BinaryOperator[BinaryOperator["In"] = 20] = "In";
+    BinaryOperator[BinaryOperator["AdditionAssignment"] = 21] = "AdditionAssignment";
+    BinaryOperator[BinaryOperator["SubtractionAssignment"] = 22] = "SubtractionAssignment";
+    BinaryOperator[BinaryOperator["MultiplicationAssignment"] = 23] = "MultiplicationAssignment";
+    BinaryOperator[BinaryOperator["DivisionAssignment"] = 24] = "DivisionAssignment";
+    BinaryOperator[BinaryOperator["RemainderAssignment"] = 25] = "RemainderAssignment";
+    BinaryOperator[BinaryOperator["ExponentiationAssignment"] = 26] = "ExponentiationAssignment";
+    BinaryOperator[BinaryOperator["AndAssignment"] = 27] = "AndAssignment";
+    BinaryOperator[BinaryOperator["OrAssignment"] = 28] = "OrAssignment";
+    BinaryOperator[BinaryOperator["NullishCoalesceAssignment"] = 29] = "NullishCoalesceAssignment";
 })(BinaryOperator || (BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
     if (base == null || other == null) {
@@ -1680,6 +1689,19 @@ class BinaryOperatorExpr extends Expression {
     clone() {
         return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan);
     }
+    isAssignment() {
+        const op = this.operator;
+        return (op === BinaryOperator.Assign ||
+            op === BinaryOperator.AdditionAssignment ||
+            op === BinaryOperator.SubtractionAssignment ||
+            op === BinaryOperator.MultiplicationAssignment ||
+            op === BinaryOperator.DivisionAssignment ||
+            op === BinaryOperator.RemainderAssignment ||
+            op === BinaryOperator.ExponentiationAssignment ||
+            op === BinaryOperator.AndAssignment ||
+            op === BinaryOperator.OrAssignment ||
+            op === BinaryOperator.NullishCoalesceAssignment);
+    }
 }
 class ReadPropExpr extends Expression {
     receiver;
@@ -2596,6 +2618,23 @@ class Identifiers {
     static element = { name: 'ɵɵelement', moduleName: CORE };
     static elementStart = { name: 'ɵɵelementStart', moduleName: CORE };
     static elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE };
+    static domElement = { name: 'ɵɵdomElement', moduleName: CORE };
+    static domElementStart = { name: 'ɵɵdomElementStart', moduleName: CORE };
+    static domElementEnd = { name: 'ɵɵdomElementEnd', moduleName: CORE };
+    static domElementContainer = {
+        name: 'ɵɵdomElementContainer',
+        moduleName: CORE,
+    };
+    static domElementContainerStart = {
+        name: 'ɵɵdomElementContainerStart',
+        moduleName: CORE,
+    };
+    static domElementContainerEnd = {
+        name: 'ɵɵdomElementContainerEnd',
+        moduleName: CORE,
+    };
+    static domTemplate = { name: 'ɵɵdomTemplate', moduleName: CORE };
+    static domListener = { name: 'ɵɵdomListener', moduleName: CORE };
     static advance = { name: 'ɵɵadvance', moduleName: CORE };
     static syntheticHostProperty = {
         name: 'ɵɵsyntheticHostProperty',
@@ -3210,6 +3249,38 @@ class _EmittedLine {
         this.indent = indent;
     }
 }
+const BINARY_OPERATORS$1 = new Map([
+    [BinaryOperator.And, '&&'],
+    [BinaryOperator.Bigger, '>'],
+    [BinaryOperator.BiggerEquals, '>='],
+    [BinaryOperator.BitwiseOr, '|'],
+    [BinaryOperator.BitwiseAnd, '&'],
+    [BinaryOperator.Divide, '/'],
+    [BinaryOperator.Assign, '='],
+    [BinaryOperator.Equals, '=='],
+    [BinaryOperator.Identical, '==='],
+    [BinaryOperator.Lower, '<'],
+    [BinaryOperator.LowerEquals, '<='],
+    [BinaryOperator.Minus, '-'],
+    [BinaryOperator.Modulo, '%'],
+    [BinaryOperator.Exponentiation, '**'],
+    [BinaryOperator.Multiply, '*'],
+    [BinaryOperator.NotEquals, '!='],
+    [BinaryOperator.NotIdentical, '!=='],
+    [BinaryOperator.NullishCoalesce, '??'],
+    [BinaryOperator.Or, '||'],
+    [BinaryOperator.Plus, '+'],
+    [BinaryOperator.In, 'in'],
+    [BinaryOperator.AdditionAssignment, '+='],
+    [BinaryOperator.SubtractionAssignment, '-='],
+    [BinaryOperator.MultiplicationAssignment, '*='],
+    [BinaryOperator.DivisionAssignment, '/='],
+    [BinaryOperator.RemainderAssignment, '%='],
+    [BinaryOperator.ExponentiationAssignment, '**='],
+    [BinaryOperator.AndAssignment, '&&='],
+    [BinaryOperator.OrAssignment, '||='],
+    [BinaryOperator.NullishCoalesceAssignment, '??='],
+]);
 class EmitterVisitorContext {
     _indent;
     static createRoot() {
@@ -3532,79 +3603,15 @@ class AbstractEmitterVisitor {
         return null;
     }
     visitBinaryOperatorExpr(ast, ctx) {
-        let opStr;
-        switch (ast.operator) {
-            case BinaryOperator.Assign:
-                opStr = '=';
-                break;
-            case BinaryOperator.Equals:
-                opStr = '==';
-                break;
-            case BinaryOperator.Identical:
-                opStr = '===';
-                break;
-            case BinaryOperator.NotEquals:
-                opStr = '!=';
-                break;
-            case BinaryOperator.NotIdentical:
-                opStr = '!==';
-                break;
-            case BinaryOperator.And:
-                opStr = '&&';
-                break;
-            case BinaryOperator.BitwiseOr:
-                opStr = '|';
-                break;
-            case BinaryOperator.BitwiseAnd:
-                opStr = '&';
-                break;
-            case BinaryOperator.Or:
-                opStr = '||';
-                break;
-            case BinaryOperator.Plus:
-                opStr = '+';
-                break;
-            case BinaryOperator.Minus:
-                opStr = '-';
-                break;
-            case BinaryOperator.Divide:
-                opStr = '/';
-                break;
-            case BinaryOperator.Multiply:
-                opStr = '*';
-                break;
-            case BinaryOperator.Modulo:
-                opStr = '%';
-                break;
-            case BinaryOperator.Exponentiation:
-                opStr = '**';
-                break;
-            case BinaryOperator.Lower:
-                opStr = '<';
-                break;
-            case BinaryOperator.LowerEquals:
-                opStr = '<=';
-                break;
-            case BinaryOperator.Bigger:
-                opStr = '>';
-                break;
-            case BinaryOperator.BiggerEquals:
-                opStr = '>=';
-                break;
-            case BinaryOperator.NullishCoalesce:
-                opStr = '??';
-                break;
-            case BinaryOperator.In:
-                opStr = 'in';
-                break;
-            default:
-                throw new Error(`Unknown operator ${ast.operator}`);
+        const operator = BINARY_OPERATORS$1.get(ast.operator);
+        if (!operator) {
+            throw new Error(`Unknown operator ${ast.operator}`);
         }
         const parens = ast !== this.lastIfCondition;
         if (parens)
             ctx.print(ast, `(`);
         ast.lhs.visitExpression(this, ctx);
-        ctx.print(ast, ` ${opStr} `);
+        ctx.print(ast, ` ${operator} `);
         ast.rhs.visitExpression(this, ctx);
         if (parens)
             ctx.print(ast, `)`);
@@ -3969,18 +3976,6 @@ function getInjectFn(target) {
     }
 }
 
-class ParserError {
-    input;
-    errLocation;
-    ctxLocation;
-    message;
-    constructor(message, input, errLocation, ctxLocation) {
-        this.input = input;
-        this.errLocation = errLocation;
-        this.ctxLocation = ctxLocation;
-        this.message = `Parser Error: ${message} ${errLocation} [${input}] in ${ctxLocation}`;
-    }
-}
 class ParseSpan {
     start;
     end;
@@ -4199,6 +4194,18 @@ class Binary extends AST {
     visit(visitor, context = null) {
         return visitor.visitBinary(this, context);
     }
+    static isAssignmentOperation(op) {
+        return (op === '=' ||
+            op === '+=' ||
+            op === '-=' ||
+            op === '*=' ||
+            op === '/=' ||
+            op === '%=' ||
+            op === '**=' ||
+            op === '&&=' ||
+            op === '||=' ||
+            op === '??=');
+    }
 }
 /**
  * For backwards compatibility reasons, `Unary` inherits from `Binary` and mimics the binary AST
@@ -4529,7 +4536,7 @@ class ParsedProperty {
     keySpan;
     valueSpan;
     isLiteral;
-    isAnimation;
+    isLegacyAnimation;
     constructor(name, expression, type, sourceSpan, keySpan, valueSpan) {
         this.name = name;
         this.expression = expression;
@@ -4538,22 +4545,22 @@ class ParsedProperty {
         this.keySpan = keySpan;
         this.valueSpan = valueSpan;
         this.isLiteral = this.type === ParsedPropertyType.LITERAL_ATTR;
-        this.isAnimation = this.type === ParsedPropertyType.ANIMATION;
+        this.isLegacyAnimation = this.type === ParsedPropertyType.LEGACY_ANIMATION;
     }
 }
 var ParsedPropertyType;
 (function (ParsedPropertyType) {
     ParsedPropertyType[ParsedPropertyType["DEFAULT"] = 0] = "DEFAULT";
     ParsedPropertyType[ParsedPropertyType["LITERAL_ATTR"] = 1] = "LITERAL_ATTR";
-    ParsedPropertyType[ParsedPropertyType["ANIMATION"] = 2] = "ANIMATION";
+    ParsedPropertyType[ParsedPropertyType["LEGACY_ANIMATION"] = 2] = "LEGACY_ANIMATION";
     ParsedPropertyType[ParsedPropertyType["TWO_WAY"] = 3] = "TWO_WAY";
 })(ParsedPropertyType || (ParsedPropertyType = {}));
 var ParsedEventType;
 (function (ParsedEventType) {
     // DOM or Directive event
     ParsedEventType[ParsedEventType["Regular"] = 0] = "Regular";
-    // Animation specific event
-    ParsedEventType[ParsedEventType["Animation"] = 1] = "Animation";
+    // Legacy animation specific event
+    ParsedEventType[ParsedEventType["LegacyAnimation"] = 1] = "LegacyAnimation";
     // Event side of a two-way binding (e.g. `[(property)]="expression"`).
     ParsedEventType[ParsedEventType["TwoWay"] = 2] = "TwoWay";
 })(ParsedEventType || (ParsedEventType = {}));
@@ -4602,8 +4609,8 @@ var BindingType;
     BindingType[BindingType["Class"] = 2] = "Class";
     // A binding to a style rule (e.g. `[style.rule]="expression"`).
     BindingType[BindingType["Style"] = 3] = "Style";
-    // A binding to an animation reference (e.g. `[animate.key]="expression"`).
-    BindingType[BindingType["Animation"] = 4] = "Animation";
+    // A binding to a legacy animation reference (e.g. `[animate.key]="expression"`).
+    BindingType[BindingType["LegacyAnimation"] = 4] = "LegacyAnimation";
     // Property side of a two-way binding (e.g. `[(property)]="expression"`).
     BindingType[BindingType["TwoWay"] = 5] = "TwoWay";
 })(BindingType || (BindingType = {}));
@@ -4786,7 +4793,7 @@ class BoundEvent {
     }
     static fromParsedEvent(event) {
         const target = event.type === ParsedEventType.Regular ? event.targetOrPhase : null;
-        const phase = event.type === ParsedEventType.Animation ? event.targetOrPhase : null;
+        const phase = event.type === ParsedEventType.LegacyAnimation ? event.targetOrPhase : null;
         if (event.keySpan === undefined) {
             throw new Error(`Unexpected state: keySpan must be defined for bound event but was not for ${event.name}: ${event.sourceSpan}`);
         }
@@ -8912,9 +8919,9 @@ var BindingKind;
      */
     BindingKind[BindingKind["I18n"] = 5] = "I18n";
     /**
-     * Animation property bindings.
+     * Legacy animation property bindings.
      */
-    BindingKind[BindingKind["Animation"] = 6] = "Animation";
+    BindingKind[BindingKind["LegacyAnimation"] = 6] = "LegacyAnimation";
     /**
      * Property side of a two-way binding.
      */
@@ -9159,13 +9166,13 @@ function createBindingOp(target, kind, name, expression, unit, securityContext,
 /**
  * Create a `PropertyOp`.
  */
-function createPropertyOp(target, name, expression, isAnimationTrigger, securityContext, isStructuralTemplateAttribute, templateKind, i18nContext, i18nMessage, sourceSpan) {
+function createPropertyOp(target, name, expression, isLegacyAnimationTrigger, securityContext, isStructuralTemplateAttribute, templateKind, i18nContext, i18nMessage, sourceSpan) {
     return {
         kind: OpKind.Property,
         target,
         name,
         expression,
-        isAnimationTrigger,
+        isLegacyAnimationTrigger,
         securityContext,
         sanitizer: null,
         isStructuralTemplateAttribute,
@@ -10852,7 +10859,7 @@ function createTextOp(xref, initialValue, icuPlaceholder, sourceSpan) {
 /**
  * Create a `ListenerOp`. Host bindings reuse all the listener logic.
  */
-function createListenerOp(target, targetSlot, name, tag, handlerOps, animationPhase, eventTarget, hostListener, sourceSpan) {
+function createListenerOp(target, targetSlot, name, tag, handlerOps, legacyAnimationPhase, eventTarget, hostListener, sourceSpan) {
     const handlerList = new OpList();
     handlerList.push(handlerOps);
     return {
@@ -10865,8 +10872,8 @@ function createListenerOp(target, targetSlot, name, tag, handlerOps, animationPh
         handlerOps: handlerList,
         handlerFnName: null,
         consumesDollarEvent: false,
-        isAnimationListener: animationPhase !== null,
-        animationPhase,
+        isLegacyAnimationListener: legacyAnimationPhase !== null,
+        legacyAnimationPhase: legacyAnimationPhase,
         eventTarget,
         sourceSpan,
         ...NEW_OP,
@@ -11121,12 +11128,12 @@ function createSourceLocationOp(templatePath, locations) {
     };
 }
 
-function createDomPropertyOp(name, expression, isAnimationTrigger, i18nContext, securityContext, sourceSpan) {
+function createDomPropertyOp(name, expression, isLegacyAnimationTrigger, i18nContext, securityContext, sourceSpan) {
     return {
         kind: OpKind.DomProperty,
         name,
         expression,
-        isAnimationTrigger,
+        isLegacyAnimationTrigger,
         i18nContext,
         securityContext,
         sanitizer: null,
@@ -11148,6 +11155,14 @@ var CompilationJobKind;
     CompilationJobKind[CompilationJobKind["Host"] = 1] = "Host";
     CompilationJobKind[CompilationJobKind["Both"] = 2] = "Both";
 })(CompilationJobKind || (CompilationJobKind = {}));
+/** Possible modes in which a component's template can be compiled. */
+var TemplateCompilationMode;
+(function (TemplateCompilationMode) {
+    /** Supports the full instruction set, including directives. */
+    TemplateCompilationMode[TemplateCompilationMode["Full"] = 0] = "Full";
+    /** Uses a narrower instruction set that doesn't support directives and allows optimizations. */
+    TemplateCompilationMode[TemplateCompilationMode["DomOnly"] = 1] = "DomOnly";
+})(TemplateCompilationMode || (TemplateCompilationMode = {}));
 /**
  * An entire ongoing compilation, which will result in one or more template functions when complete.
  * Contains one or more corresponding compilation units.
@@ -11156,10 +11171,12 @@ class CompilationJob {
     componentName;
     pool;
     compatibility;
-    constructor(componentName, pool, compatibility) {
+    mode;
+    constructor(componentName, pool, compatibility, mode) {
         this.componentName = componentName;
         this.pool = pool;
         this.compatibility = compatibility;
+        this.mode = mode;
     }
     kind = CompilationJobKind.Both;
     /**
@@ -11184,8 +11201,8 @@ class ComponentCompilationJob extends CompilationJob {
     allDeferrableDepsFn;
     relativeTemplatePath;
     enableDebugLocations;
-    constructor(componentName, pool, compatibility, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
-        super(componentName, pool, compatibility);
+    constructor(componentName, pool, compatibility, mode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
+        super(componentName, pool, compatibility, mode);
         this.relativeContextFilePath = relativeContextFilePath;
         this.i18nUseExternalIds = i18nUseExternalIds;
         this.deferMeta = deferMeta;
@@ -11330,8 +11347,8 @@ class ViewCompilationUnit extends CompilationUnit {
  * Compilation-in-progress of a host binding, which contains a single unit for that host binding.
  */
 class HostBindingCompilationJob extends CompilationJob {
-    constructor(componentName, pool, compatibility) {
-        super(componentName, pool, compatibility);
+    constructor(componentName, pool, compatibility, mode) {
+        super(componentName, pool, compatibility, mode);
         this.root = new HostBindingCompilationUnit(this);
     }
     kind = CompilationJobKind.Host;
@@ -11563,7 +11580,7 @@ function extractAttributes(job) {
                     extractAttributeOp(unit, op, elements);
                     break;
                 case OpKind.Property:
-                    if (!op.isAnimationTrigger) {
+                    if (!op.isLegacyAnimationTrigger) {
                         let bindingKind;
                         if (op.i18nMessage !== null && op.templateKind === null) {
                             // If the binding has an i18n context, it is an i18n attribute, and should have that
@@ -11605,7 +11622,7 @@ function extractAttributes(job) {
                     }
                     break;
                 case OpKind.Listener:
-                    if (!op.isAnimationListener) {
+                    if (!op.isLegacyAnimationListener) {
                         const extractedAttributeOp = createExtractedAttributeOp(op.target, BindingKind.Property, null, op.name, 
                         /* expression */ null, 
                         /* i18nContext */ null, 
@@ -11715,12 +11732,12 @@ function specializeBindings(job) {
                     }
                     break;
                 case BindingKind.Property:
-                case BindingKind.Animation:
+                case BindingKind.LegacyAnimation:
                     if (job.kind === CompilationJobKind.Host) {
-                        OpList.replace(op, createDomPropertyOp(op.name, op.expression, op.bindingKind === BindingKind.Animation, op.i18nContext, op.securityContext, op.sourceSpan));
+                        OpList.replace(op, createDomPropertyOp(op.name, op.expression, op.bindingKind === BindingKind.LegacyAnimation, op.i18nContext, op.securityContext, op.sourceSpan));
                     }
                     else {
-                        OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind === BindingKind.Animation, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
+                        OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind === BindingKind.LegacyAnimation, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
                     }
                     break;
                 case BindingKind.TwoWayProperty:
@@ -11764,6 +11781,14 @@ const CHAIN_COMPATIBILITY = new Map([
     [Identifiers.declareLet, Identifiers.declareLet],
     [Identifiers.conditionalCreate, Identifiers.conditionalBranchCreate],
     [Identifiers.conditionalBranchCreate, Identifiers.conditionalBranchCreate],
+    [Identifiers.domElement, Identifiers.domElement],
+    [Identifiers.domElementStart, Identifiers.domElementStart],
+    [Identifiers.domElementEnd, Identifiers.domElementEnd],
+    [Identifiers.domElementContainer, Identifiers.domElementContainer],
+    [Identifiers.domElementContainerStart, Identifiers.domElementContainerStart],
+    [Identifiers.domElementContainerEnd, Identifiers.domElementContainerEnd],
+    [Identifiers.domListener, Identifiers.domListener],
+    [Identifiers.domTemplate, Identifiers.domTemplate],
 ]);
 /**
  * Chaining results in repeated call expressions, causing a deep AST of receiver expressions. To prevent running out of
@@ -11936,6 +11961,15 @@ const BINARY_OPERATORS = new Map([
     ['||', BinaryOperator.Or],
     ['+', BinaryOperator.Plus],
     ['in', BinaryOperator.In],
+    ['+=', BinaryOperator.AdditionAssignment],
+    ['-=', BinaryOperator.SubtractionAssignment],
+    ['*=', BinaryOperator.MultiplicationAssignment],
+    ['/=', BinaryOperator.DivisionAssignment],
+    ['%=', BinaryOperator.RemainderAssignment],
+    ['**=', BinaryOperator.ExponentiationAssignment],
+    ['&&=', BinaryOperator.AndAssignment],
+    ['||=', BinaryOperator.OrAssignment],
+    ['??=', BinaryOperator.NullishCoalesceAssignment],
 ]);
 function namespaceForKey(namespacePrefixKey) {
     const NAMESPACES = new Map([
@@ -15714,13 +15748,6 @@ const NAMED_ENTITIES = {
 const NGSP_UNICODE = '\uE500';
 NAMED_ENTITIES['ngsp'] = NGSP_UNICODE;
 
-class TokenError extends ParseError {
-    tokenType;
-    constructor(errorMsg, tokenType, span) {
-        super(span, errorMsg);
-        this.tokenType = tokenType;
-    }
-}
 class TokenizeResult {
     tokens;
     errors;
@@ -15752,12 +15779,6 @@ var CharacterReferenceType;
     CharacterReferenceType["HEX"] = "hexadecimal";
     CharacterReferenceType["DEC"] = "decimal";
 })(CharacterReferenceType || (CharacterReferenceType = {}));
-class _ControlFlowError {
-    error;
-    constructor(error) {
-        this.error = error;
-    }
-}
 // See https://www.w3.org/TR/html51/syntax.html#writing-html-documents
 class _Tokenizer {
     _getTagDefinition;
@@ -16067,10 +16088,10 @@ class _Tokenizer {
     }
     _endToken(parts, end) {
         if (this._currentTokenStart === null) {
-            throw new TokenError('Programming error - attempted to end a token when there was no start to the token', this._currentTokenType, this._cursor.getSpan(end));
+            throw new ParseError(this._cursor.getSpan(end), 'Programming error - attempted to end a token when there was no start to the token');
         }
         if (this._currentTokenType === null) {
-            throw new TokenError('Programming error - attempted to end a token which has no token type', null, this._cursor.getSpan(this._currentTokenStart));
+            throw new ParseError(this._cursor.getSpan(this._currentTokenStart), 'Programming error - attempted to end a token which has no token type');
         }
         const token = {
             type: this._currentTokenType,
@@ -16086,17 +16107,17 @@ class _Tokenizer {
         if (this._isInExpansionForm()) {
             msg += ` (Do you have an unescaped "{" in your template? Use "{{ '{' }}") to escape it.)`;
         }
-        const error = new TokenError(msg, this._currentTokenType, span);
+        const error = new ParseError(span, msg);
         this._currentTokenStart = null;
         this._currentTokenType = null;
-        return new _ControlFlowError(error);
+        return error;
     }
     handleError(e) {
         if (e instanceof CursorError) {
             e = this._createError(e.msg, this._cursor.getSpan(e.cursor));
         }
-        if (e instanceof _ControlFlowError) {
-            this.errors.push(e.error);
+        if (e instanceof ParseError) {
+            this.errors.push(e);
         }
         else {
             throw e;
@@ -16336,7 +16357,7 @@ class _Tokenizer {
             }
         }
         catch (e) {
-            if (e instanceof _ControlFlowError) {
+            if (e instanceof ParseError) {
                 if (openToken) {
                     // We errored before we could close the opening tag, so it is incomplete.
                     openToken.type =
@@ -17117,7 +17138,7 @@ let Parser$1 = class Parser {
         const tokenizeResult = tokenize(source, url, this.getTagDefinition, options);
         const parser = new _TreeBuilder(tokenizeResult.tokens, this.getTagDefinition);
         parser.build();
-        return new ParseTreeResult(parser.rootNodes, tokenizeResult.errors.concat(parser.errors));
+        return new ParseTreeResult(parser.rootNodes, [...tokenizeResult.errors, ...parser.errors]);
     }
 };
 class _TreeBuilder {
@@ -18208,13 +18229,17 @@ class _Scanner {
             case $HASH:
                 return this.scanPrivateIdentifier();
             case $PLUS:
+                return this.scanComplexOperator(start, '+', $EQ, '=');
             case $MINUS:
+                return this.scanComplexOperator(start, '-', $EQ, '=');
             case $SLASH:
+                return this.scanComplexOperator(start, '/', $EQ, '=');
             case $PERCENT:
+                return this.scanComplexOperator(start, '%', $EQ, '=');
             case $CARET:
-                return this.scanOperator(start, String.fromCharCode(peek));
+                return this.scanOperator(start, '^');
             case $STAR:
-                return this.scanComplexOperator(start, '*', $STAR, '*');
+                return this.scanStar(start);
             case $QUESTION:
                 return this.scanQuestion(start);
             case $LT:
@@ -18224,9 +18249,9 @@ class _Scanner {
             case $EQ:
                 return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, '=', $EQ, '=');
             case $AMPERSAND:
-                return this.scanComplexOperator(start, '&', $AMPERSAND, '&');
+                return this.scanComplexOperator(start, '&', $AMPERSAND, '&', $EQ, '=');
             case $BAR:
-                return this.scanComplexOperator(start, '|', $BAR, '|');
+                return this.scanComplexOperator(start, '|', $BAR, '|', $EQ, '=');
             case $NBSP:
                 while (isWhitespace(this.peek))
                     this.advance();
@@ -18372,13 +18397,23 @@ class _Scanner {
     }
     scanQuestion(start) {
         this.advance();
-        let str = '?';
-        // Either `a ?? b` or 'a?.b'.
-        if (this.peek === $QUESTION || this.peek === $PERIOD) {
-            str += this.peek === $PERIOD ? '.' : '?';
+        let operator = '?';
+        // `a ?? b` or `a ??= b`.
+        if (this.peek === $QUESTION) {
+            operator += '?';
             this.advance();
+            // @ts-expect-error
+            if (this.peek === $EQ) {
+                operator += '=';
+                this.advance();
+            }
         }
-        return newOperatorToken(start, this.index, str);
+        else if (this.peek === $PERIOD) {
+            // `a?.b`
+            operator += '.';
+            this.advance();
+        }
+        return newOperatorToken(start, this.index, operator);
     }
     scanTemplateLiteralPart(start) {
         let buffer = '';
@@ -18442,6 +18477,25 @@ class _Scanner {
         buffer += String.fromCharCode(unescapedCode);
         return buffer;
     }
+    scanStar(start) {
+        this.advance();
+        // `*`, `**`, `**=` or `*=`
+        let operator = '*';
+        if (this.peek === $STAR) {
+            operator += '*';
+            this.advance();
+            // @ts-expect-error
+            if (this.peek === $EQ) {
+                operator += '=';
+                this.advance();
+            }
+        }
+        else if (this.peek === $EQ) {
+            operator += '=';
+            this.advance();
+        }
+        return newOperatorToken(start, this.index, operator);
+    }
 }
 function isIdentifierStart(code) {
     return (($a <= code && code <= $z) ||
@@ -18502,6 +18556,9 @@ class TemplateBindingParseResult {
         this.errors = errors;
     }
 }
+function getLocation(span) {
+    return span.start.toString() || '(unknown)';
+}
 class Parser {
     _lexer;
     _supportsDirectPipeReferences;
@@ -18509,18 +18566,18 @@ class Parser {
         this._lexer = _lexer;
         this._supportsDirectPipeReferences = _supportsDirectPipeReferences;
     }
-    parseAction(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseAction(input, parseSourceSpan, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         const errors = [];
-        this._checkNoInterpolation(errors, input, location, interpolationConfig);
+        this._checkNoInterpolation(errors, input, parseSourceSpan, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        const ast = new _ParseAST(input, location, absoluteOffset, tokens, 1 /* ParseFlags.Action */, errors, 0, this._supportsDirectPipeReferences).parseChain();
-        return new ASTWithSource(ast, input, location, absoluteOffset, errors);
+        const ast = new _ParseAST(input, parseSourceSpan, absoluteOffset, tokens, 1 /* ParseFlags.Action */, errors, 0, this._supportsDirectPipeReferences).parseChain();
+        return new ASTWithSource(ast, input, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
-    parseBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseBinding(input, parseSourceSpan, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         const errors = [];
-        const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig, errors);
-        return new ASTWithSource(ast, input, location, absoluteOffset, errors);
+        const ast = this._parseBindingAst(input, parseSourceSpan, absoluteOffset, interpolationConfig, errors);
+        return new ASTWithSource(ast, input, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
     checkSimpleExpression(ast) {
         const checker = new SimpleExpressionChecker();
@@ -18528,20 +18585,20 @@ class Parser {
         return checker.errors;
     }
     // Host bindings parsed here
-    parseSimpleBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseSimpleBinding(input, parseSourceSpan, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         const errors = [];
-        const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig, errors);
+        const ast = this._parseBindingAst(input, parseSourceSpan, absoluteOffset, interpolationConfig, errors);
         const simplExpressionErrors = this.checkSimpleExpression(ast);
         if (simplExpressionErrors.length > 0) {
-            errors.push(new ParserError(`Host binding expression cannot contain ${simplExpressionErrors.join(' ')}`, input, location));
+            errors.push(getParseError(`Host binding expression cannot contain ${simplExpressionErrors.join(' ')}`, input, '', parseSourceSpan));
         }
-        return new ASTWithSource(ast, input, location, absoluteOffset, errors);
+        return new ASTWithSource(ast, input, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
-    _parseBindingAst(input, location, absoluteOffset, interpolationConfig, errors) {
-        this._checkNoInterpolation(errors, input, location, interpolationConfig);
+    _parseBindingAst(input, parseSourceSpan, absoluteOffset, interpolationConfig, errors) {
+        this._checkNoInterpolation(errors, input, parseSourceSpan, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        return new _ParseAST(input, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, 0, this._supportsDirectPipeReferences).parseChain();
+        return new _ParseAST(input, parseSourceSpan, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, 0, this._supportsDirectPipeReferences).parseChain();
     }
     /**
      * Parse microsyntax template expression and return a list of bindings or
@@ -18569,42 +18626,46 @@ class Parser {
      * @param absoluteKeyOffset start of the `templateKey`
      * @param absoluteValueOffset start of the `templateValue`
      */
-    parseTemplateBindings(templateKey, templateValue, templateUrl, absoluteKeyOffset, absoluteValueOffset) {
+    parseTemplateBindings(templateKey, templateValue, parseSourceSpan, absoluteKeyOffset, absoluteValueOffset) {
         const tokens = this._lexer.tokenize(templateValue);
         const errors = [];
-        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, 0 /* ParseFlags.None */, errors, 0 /* relative offset */, this._supportsDirectPipeReferences);
+        const parser = new _ParseAST(templateValue, parseSourceSpan, absoluteValueOffset, tokens, 0 /* ParseFlags.None */, errors, 0 /* relative offset */, this._supportsDirectPipeReferences);
         return parser.parseTemplateBindings({
             source: templateKey,
             span: new AbsoluteSourceSpan(absoluteKeyOffset, absoluteKeyOffset + templateKey.length),
         });
     }
-    parseInterpolation(input, location, absoluteOffset, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseInterpolation(input, parseSourceSpan, absoluteOffset, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         const errors = [];
-        const { strings, expressions, offsets } = this.splitInterpolation(input, location, errors, interpolatedTokens, interpolationConfig);
+        const { strings, expressions, offsets } = this.splitInterpolation(input, parseSourceSpan, errors, interpolatedTokens, interpolationConfig);
         if (expressions.length === 0)
             return null;
         const expressionNodes = [];
         for (let i = 0; i < expressions.length; ++i) {
+            // If we have a token for the specific expression, it's preferrable to use it because it
+            // allows us to produce more accurate error messages. The expressions are always at the odd
+            // indexes inside the tokens.
+            const expressionSpan = interpolatedTokens?.[i * 2 + 1]?.sourceSpan;
             const expressionText = expressions[i].text;
             const sourceToLex = this._stripComments(expressionText);
             const tokens = this._lexer.tokenize(sourceToLex);
-            const ast = new _ParseAST(input, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, offsets[i], this._supportsDirectPipeReferences).parseChain();
+            const ast = new _ParseAST(expressionSpan ? expressionText : input, expressionSpan || parseSourceSpan, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, offsets[i], this._supportsDirectPipeReferences).parseChain();
             expressionNodes.push(ast);
         }
-        return this.createInterpolationAst(strings.map((s) => s.text), expressionNodes, input, location, absoluteOffset, errors);
+        return this.createInterpolationAst(strings.map((s) => s.text), expressionNodes, input, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
     /**
      * Similar to `parseInterpolation`, but treats the provided string as a single expression
      * element that would normally appear within the interpolation prefix and suffix (`{{` and `}}`).
      * This is used for parsing the switch expression in ICUs.
      */
-    parseInterpolationExpression(expression, location, absoluteOffset) {
+    parseInterpolationExpression(expression, parseSourceSpan, absoluteOffset) {
         const sourceToLex = this._stripComments(expression);
         const tokens = this._lexer.tokenize(sourceToLex);
         const errors = [];
-        const ast = new _ParseAST(expression, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, 0, this._supportsDirectPipeReferences).parseChain();
+        const ast = new _ParseAST(expression, parseSourceSpan, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, 0, this._supportsDirectPipeReferences).parseChain();
         const strings = ['', '']; // The prefix and suffix strings are both empty
-        return this.createInterpolationAst(strings, [ast], expression, location, absoluteOffset, errors);
+        return this.createInterpolationAst(strings, [ast], expression, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
     createInterpolationAst(strings, expressions, input, location, absoluteOffset, errors) {
         const span = new ParseSpan(0, input.length);
@@ -18618,7 +18679,7 @@ class Parser {
      * `SplitInterpolation` with splits that look like
      *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
      */
-    splitInterpolation(input, location, errors, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    splitInterpolation(input, parseSourceSpan, errors, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         const strings = [];
         const expressions = [];
         const offsets = [];
@@ -18656,7 +18717,7 @@ class Parser {
                 const fullEnd = exprEnd + interpEnd.length;
                 const text = input.substring(exprStart, exprEnd);
                 if (text.trim().length === 0) {
-                    errors.push(new ParserError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, location));
+                    errors.push(getParseError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, parseSourceSpan));
                 }
                 expressions.push({ text, start: fullStart, end: fullEnd });
                 const startInOriginalTemplate = inputToTemplateIndexMap?.get(fullStart) ?? fullStart;
@@ -18679,9 +18740,11 @@ class Parser {
         }
         return new SplitInterpolation(strings, expressions, offsets);
     }
-    wrapLiteralPrimitive(input, location, absoluteOffset) {
+    wrapLiteralPrimitive(input, sourceSpanOrLocation, absoluteOffset) {
         const span = new ParseSpan(0, input == null ? 0 : input.length);
-        return new ASTWithSource(new LiteralPrimitive(span, span.toAbsolute(absoluteOffset), input), input, location, absoluteOffset, []);
+        return new ASTWithSource(new LiteralPrimitive(span, span.toAbsolute(absoluteOffset), input), input, typeof sourceSpanOrLocation === 'string'
+            ? sourceSpanOrLocation
+            : getLocation(sourceSpanOrLocation), absoluteOffset, []);
     }
     _stripComments(input) {
         const i = this._commentStart(input);
@@ -18703,7 +18766,7 @@ class Parser {
         }
         return null;
     }
-    _checkNoInterpolation(errors, input, location, { start, end }) {
+    _checkNoInterpolation(errors, input, parseSourceSpan, { start, end }) {
         let startIndex = -1;
         let endIndex = -1;
         for (const charIndex of this._forEachUnquotedChar(input, 0)) {
@@ -18720,7 +18783,7 @@ class Parser {
             }
         }
         if (startIndex > -1 && endIndex > -1) {
-            errors.push(new ParserError(`Got interpolation (${start}${end}) where expression was expected`, input, `at column ${startIndex} in`, location));
+            errors.push(getParseError(`Got interpolation (${start}${end}) where expression was expected`, input, `at column ${startIndex} in`, parseSourceSpan));
         }
     }
     /**
@@ -18779,7 +18842,7 @@ var ParseContextFlags;
 })(ParseContextFlags || (ParseContextFlags = {}));
 class _ParseAST {
     input;
-    location;
+    parseSourceSpan;
     absoluteOffset;
     tokens;
     parseFlags;
@@ -18796,9 +18859,9 @@ class _ParseAST {
     // and may change for subsequent expressions visited by the parser.
     sourceSpanCache = new Map();
     index = 0;
-    constructor(input, location, absoluteOffset, tokens, parseFlags, errors, offset, supportsDirectPipeReferences) {
+    constructor(input, parseSourceSpan, absoluteOffset, tokens, parseFlags, errors, offset, supportsDirectPipeReferences) {
         this.input = input;
-        this.location = location;
+        this.parseSourceSpan = parseSourceSpan;
         this.absoluteOffset = absoluteOffset;
         this.tokens = tokens;
         this.parseFlags = parseFlags;
@@ -18926,6 +18989,9 @@ class _ParseAST {
             return false;
         }
     }
+    isAssignmentOperator(token) {
+        return token.type === TokenType.Operator && Binary.isAssignmentOperation(token.strValue);
+    }
     expectOperator(operator) {
         if (this.consumeOptionalOperator(operator))
             return;
@@ -19409,7 +19475,8 @@ class _ParseAST {
         });
         const nameSpan = this.sourceSpan(nameStart);
         if (isSafe) {
-            if (this.consumeOptionalOperator('=')) {
+            if (this.isAssignmentOperator(this.next)) {
+                this.advance();
                 this.error("The '?.' operator cannot be used in the assignment");
                 return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
             }
@@ -19418,14 +19485,16 @@ class _ParseAST {
             }
         }
         else {
-            if (this.consumeOptionalOperator('=')) {
+            if (this.isAssignmentOperator(this.next)) {
+                const operation = this.next.strValue;
+                this.advance();
                 if (!(this.parseFlags & 1 /* ParseFlags.Action */)) {
                     this.error('Bindings cannot contain assignments');
                     return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
                 }
                 const receiver = new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
                 const value = this.parseConditional();
-                return new Binary(this.span(start), this.sourceSpan(start), '=', receiver, value);
+                return new Binary(this.span(start), this.sourceSpan(start), operation, receiver, value);
             }
             else {
                 return new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
@@ -19540,14 +19609,16 @@ class _ParseAST {
             }
             this.rbracketsExpected--;
             this.expectCharacter($RBRACKET);
-            if (this.consumeOptionalOperator('=')) {
+            if (this.isAssignmentOperator(this.next)) {
+                const operation = this.next.strValue;
+                this.advance();
                 if (isSafe) {
                     this.error("The '?.' operator cannot be used in the assignment");
                 }
                 else {
                     const binaryReceiver = new KeyedRead(this.span(start), this.sourceSpan(start), receiver, key);
                     const value = this.parseConditional();
-                    return new Binary(this.span(start), this.sourceSpan(start), '=', binaryReceiver, value);
+                    return new Binary(this.span(start), this.sourceSpan(start), operation, binaryReceiver, value);
                 }
             }
             else {
@@ -19611,7 +19682,7 @@ class _ParseAST {
         const ast = this.parsePipe(); // example: "condition | async"
         const { start, end } = ast.span;
         const value = this.input.substring(start, end);
-        return new ASTWithSource(ast, value, this.location, this.absoluteOffset + start, this.errors);
+        return new ASTWithSource(ast, value, getLocation(this.parseSourceSpan), this.absoluteOffset + start, this.errors);
     }
     /**
      * Return the binding for a variable declared using `as`. Note that the order
@@ -19715,13 +19786,11 @@ class _ParseAST {
      * Records an error and skips over the token stream until reaching a recoverable point. See
      * `this.skip` for more details on token skipping.
      */
-    error(message, index = null) {
-        this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));
+    error(message, index = this.index) {
+        this.errors.push(getParseError(message, this.input, this.getErrorLocationText(index), this.parseSourceSpan));
         this.skip();
     }
-    locationText(index = null) {
-        if (index == null)
-            index = this.index;
+    getErrorLocationText(index) {
         return index < this.tokens.length
             ? `at column ${this.tokens[index].index + 1} in`
             : `at the end of the expression`;
@@ -19755,7 +19824,7 @@ class _ParseAST {
      *       none of the calling productions are not expecting the closing token else we will never
      *       make progress in the case of an extraneous group closing symbol (such as a stray ')').
      *       That is, we skip a closing symbol if we are not in a grouping production.
-     *   - '=' in a `Writable` context
+     *   - Assignment in a `Writable` context
      *     - In this context, we are able to recover after seeing the `=` operator, which
      *       signals the presence of an independent rvalue expression following the `=` operator.
      *
@@ -19770,15 +19839,23 @@ class _ParseAST {
             (this.rparensExpected <= 0 || !n.isCharacter($RPAREN)) &&
             (this.rbracesExpected <= 0 || !n.isCharacter($RBRACE)) &&
             (this.rbracketsExpected <= 0 || !n.isCharacter($RBRACKET)) &&
-            (!(this.context & ParseContextFlags.Writable) || !n.isOperator('='))) {
+            (!(this.context & ParseContextFlags.Writable) || !this.isAssignmentOperator(n))) {
             if (this.next.isError()) {
-                this.errors.push(new ParserError(this.next.toString(), this.input, this.locationText(), this.location));
+                this.errors.push(getParseError(this.next.toString(), this.input, this.getErrorLocationText(this.next.index), this.parseSourceSpan));
             }
             this.advance();
             n = this.next;
         }
     }
 }
+function getParseError(message, input, locationText, parseSourceSpan) {
+    if (locationText.length > 0) {
+        locationText = ` ${locationText} `;
+    }
+    const location = getLocation(parseSourceSpan);
+    const error = `Parser Error: ${message}${locationText}[${input}] in ${location}`;
+    return new ParseError(parseSourceSpan, error);
+}
 class SimpleExpressionChecker extends RecursiveAstVisitor {
     errors = [];
     visitPipe() {
@@ -21033,7 +21110,7 @@ class _I18nVisitor {
     normalizeExpression(token) {
         const expression = token.parts[1];
         const expr = this._expressionParser.parseBinding(expression, 
-        /* location */ token.sourceSpan.start.toString(), 
+        /* location */ token.sourceSpan, 
         /* absoluteOffset */ token.sourceSpan.start.offset, this._interpolationConfig);
         return serialize(expr);
     }
@@ -21099,15 +21176,6 @@ function extractPlaceholderName(input) {
     return input.split(_CUSTOM_PH_EXP)[2];
 }
 
-/**
- * An i18n error.
- */
-class I18nError extends ParseError {
-    constructor(span, msg) {
-        super(span, msg);
-    }
-}
-
 /**
  * Set of tagName|propertyName corresponding to Trusted Types sinks. Properties applying to all
  * tags use '*'.
@@ -21389,7 +21457,7 @@ class I18nMetaVisitor {
         }
     }
     _reportError(node, msg) {
-        this._errors.push(new I18nError(node.sourceSpan, msg));
+        this._errors.push(new ParseError(node.sourceSpan, msg));
     }
 }
 /** I18n separators for metadata **/
@@ -22257,7 +22325,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
         switch (op.kind) {
             case OpKind.Property:
             case OpKind.DomProperty:
-                if (op.isAnimationTrigger) {
+                if (op.isLegacyAnimationTrigger) {
                     op.name = '@' + op.name;
                 }
                 break;
@@ -22269,8 +22337,8 @@ function addNamesToView(unit, baseName, state, compatibility) {
                     throw new Error(`Expected a slot to be assigned`);
                 }
                 let animation = '';
-                if (op.isAnimationListener) {
-                    op.name = `@${op.name}.${op.animationPhase}`;
+                if (op.isLegacyAnimationListener) {
+                    op.name = `@${op.name}.${op.legacyAnimationPhase}`;
                     animation = 'animation';
                 }
                 if (op.hostListener) {
@@ -22538,7 +22606,7 @@ function kindWithInterpolationTest(kind, interpolation) {
     };
 }
 function basicListenerKindTest(op) {
-    return ((op.kind === OpKind.Listener && !(op.hostListener && op.isAnimationListener)) ||
+    return ((op.kind === OpKind.Listener && !(op.hostListener && op.isLegacyAnimationListener)) ||
         op.kind === OpKind.TwoWayListener);
 }
 function nonInterpolationPropertyKindTest(op) {
@@ -22551,7 +22619,7 @@ function nonInterpolationPropertyKindTest(op) {
  * the groups in the order defined here.
  */
 const CREATE_ORDERING = [
-    { test: (op) => op.kind === OpKind.Listener && op.hostListener && op.isAnimationListener },
+    { test: (op) => op.kind === OpKind.Listener && op.hostListener && op.isLegacyAnimationListener },
     { test: basicListenerKindTest },
 ];
 /**
@@ -22973,21 +23041,7 @@ function elementOrContainerBase(instruction, slot, tag, constIndex, localRefInde
     }
     return call(instruction, args, sourceSpan);
 }
-function elementEnd(sourceSpan) {
-    return call(Identifiers.elementEnd, [], sourceSpan);
-}
-function elementContainerStart(slot, constIndex, localRefIndex, sourceSpan) {
-    return elementOrContainerBase(Identifiers.elementContainerStart, slot, 
-    /* tag */ null, constIndex, localRefIndex, sourceSpan);
-}
-function elementContainer(slot, constIndex, localRefIndex, sourceSpan) {
-    return elementOrContainerBase(Identifiers.elementContainer, slot, 
-    /* tag */ null, constIndex, localRefIndex, sourceSpan);
-}
-function elementContainerEnd() {
-    return call(Identifiers.elementContainerEnd, [], null);
-}
-function template(slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan) {
+function templateBase(instruction, slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan) {
     const args = [
         literal(slot),
         templateFnRef,
@@ -23003,7 +23057,37 @@ function template(slot, templateFnRef, decls, vars, tag, constIndex, localRefs,
     while (args[args.length - 1].isEquivalent(NULL_EXPR)) {
         args.pop();
     }
-    return call(Identifiers.templateCreate, args, sourceSpan);
+    return call(instruction, args, sourceSpan);
+}
+function propertyBase(instruction, name, expression, sanitizer, sourceSpan) {
+    const args = [literal(name)];
+    if (expression instanceof Interpolation) {
+        args.push(interpolationToExpression(expression, sourceSpan));
+    }
+    else {
+        args.push(expression);
+    }
+    if (sanitizer !== null) {
+        args.push(sanitizer);
+    }
+    return call(instruction, args, sourceSpan);
+}
+function elementEnd(sourceSpan) {
+    return call(Identifiers.elementEnd, [], sourceSpan);
+}
+function elementContainerStart(slot, constIndex, localRefIndex, sourceSpan) {
+    return elementOrContainerBase(Identifiers.elementContainerStart, slot, 
+    /* tag */ null, constIndex, localRefIndex, sourceSpan);
+}
+function elementContainer(slot, constIndex, localRefIndex, sourceSpan) {
+    return elementOrContainerBase(Identifiers.elementContainer, slot, 
+    /* tag */ null, constIndex, localRefIndex, sourceSpan);
+}
+function elementContainerEnd() {
+    return call(Identifiers.elementContainerEnd, [], null);
+}
+function template(slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan) {
+    return templateBase(Identifiers.templateCreate, slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan);
 }
 function disableBindings() {
     return call(Identifiers.disableBindings, [], null);
@@ -23269,17 +23353,7 @@ function i18nAttributes(slot, i18nAttributesConfig) {
     return call(Identifiers.i18nAttributes, args, null);
 }
 function property(name, expression, sanitizer, sourceSpan) {
-    const args = [literal(name)];
-    if (expression instanceof Interpolation) {
-        args.push(interpolationToExpression(expression, sourceSpan));
-    }
-    else {
-        args.push(expression);
-    }
-    if (sanitizer !== null) {
-        args.push(sanitizer);
-    }
-    return call(Identifiers.property, args, sourceSpan);
+    return propertyBase(Identifiers.property, name, expression, sanitizer, sourceSpan);
 }
 function twoWayProperty(name, expression, sanitizer, sourceSpan) {
     const args = [literal(name), expression];
@@ -23332,6 +23406,36 @@ function classMap(expression, sourceSpan) {
         : expression;
     return call(Identifiers.classMap, [value], sourceSpan);
 }
+function domElement(slot, tag, constIndex, localRefIndex, sourceSpan) {
+    return elementOrContainerBase(Identifiers.domElement, slot, tag, constIndex, localRefIndex, sourceSpan);
+}
+function domElementStart(slot, tag, constIndex, localRefIndex, sourceSpan) {
+    return elementOrContainerBase(Identifiers.domElementStart, slot, tag, constIndex, localRefIndex, sourceSpan);
+}
+function domElementEnd(sourceSpan) {
+    return call(Identifiers.domElementEnd, [], sourceSpan);
+}
+function domElementContainerStart(slot, constIndex, localRefIndex, sourceSpan) {
+    return elementOrContainerBase(Identifiers.domElementContainerStart, slot, 
+    /* tag */ null, constIndex, localRefIndex, sourceSpan);
+}
+function domElementContainer(slot, constIndex, localRefIndex, sourceSpan) {
+    return elementOrContainerBase(Identifiers.domElementContainer, slot, 
+    /* tag */ null, constIndex, localRefIndex, sourceSpan);
+}
+function domElementContainerEnd() {
+    return call(Identifiers.domElementContainerEnd, [], null);
+}
+function domListener(name, handlerFn, eventTargetResolver, sourceSpan) {
+    const args = [literal(name), handlerFn];
+    if (eventTargetResolver !== null) {
+        args.push(importExpr(eventTargetResolver));
+    }
+    return call(Identifiers.domListener, args, sourceSpan);
+}
+function domTemplate(slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan) {
+    return templateBase(Identifiers.domTemplate, slot, templateFnRef, decls, vars, tag, constIndex, localRefs, sourceSpan);
+}
 const PIPE_BINDINGS = [
     Identifiers.pipeBind1,
     Identifiers.pipeBind2,
@@ -23359,11 +23463,7 @@ function i18nApply(slot, sourceSpan) {
     return call(Identifiers.i18nApply, [literal(slot)], sourceSpan);
 }
 function domProperty(name, expression, sanitizer, sourceSpan) {
-    const args = [literal(name), expression];
-    if (sanitizer !== null) {
-        args.push(sanitizer);
-    }
-    return call(Identifiers.domProperty, args, sourceSpan);
+    return propertyBase(Identifiers.domProperty, name, expression, sanitizer, sourceSpan);
 }
 function syntheticHostProperty(name, expression, sourceSpan) {
     return call(Identifiers.syntheticHostProperty, [literal(name), expression], sourceSpan);
@@ -23528,22 +23628,34 @@ function reifyCreateOperations(unit, ops) {
                 OpList.replace(op, text(op.handle.slot, op.initialValue, op.sourceSpan));
                 break;
             case OpKind.ElementStart:
-                OpList.replace(op, elementStart(op.handle.slot, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly
+                    ? domElementStart(op.handle.slot, op.tag, op.attributes, op.localRefs, op.startSourceSpan)
+                    : elementStart(op.handle.slot, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.Element:
-                OpList.replace(op, element(op.handle.slot, op.tag, op.attributes, op.localRefs, op.wholeSourceSpan));
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly
+                    ? domElement(op.handle.slot, op.tag, op.attributes, op.localRefs, op.wholeSourceSpan)
+                    : element(op.handle.slot, op.tag, op.attributes, op.localRefs, op.wholeSourceSpan));
                 break;
             case OpKind.ElementEnd:
-                OpList.replace(op, elementEnd(op.sourceSpan));
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly
+                    ? domElementEnd(op.sourceSpan)
+                    : elementEnd(op.sourceSpan));
                 break;
             case OpKind.ContainerStart:
-                OpList.replace(op, elementContainerStart(op.handle.slot, op.attributes, op.localRefs, op.startSourceSpan));
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly
+                    ? domElementContainerStart(op.handle.slot, op.attributes, op.localRefs, op.startSourceSpan)
+                    : elementContainerStart(op.handle.slot, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.Container:
-                OpList.replace(op, elementContainer(op.handle.slot, op.attributes, op.localRefs, op.wholeSourceSpan));
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly
+                    ? domElementContainer(op.handle.slot, op.attributes, op.localRefs, op.wholeSourceSpan)
+                    : elementContainer(op.handle.slot, op.attributes, op.localRefs, op.wholeSourceSpan));
                 break;
             case OpKind.ContainerEnd:
-                OpList.replace(op, elementContainerEnd());
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly
+                    ? domElementContainerEnd()
+                    : elementContainerEnd());
                 break;
             case OpKind.I18nStart:
                 OpList.replace(op, i18nStart(op.handle.slot, op.messageIndex, op.subTemplateIndex, op.sourceSpan));
@@ -23568,7 +23680,12 @@ function reifyCreateOperations(unit, ops) {
                     throw new Error(`AssertionError: local refs array should have been extracted into a constant`);
                 }
                 const childView = unit.job.views.get(op.xref);
-                OpList.replace(op, template(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
+                OpList.replace(op, 
+                // Block templates can't have directives so we can always generate them as DOM-only.
+                op.templateKind === TemplateKind.Block ||
+                    unit.job.mode === TemplateCompilationMode.DomOnly
+                    ? domTemplate(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.localRefs, op.startSourceSpan)
+                    : template(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.DisableBindings:
                 OpList.replace(op, disableBindings());
@@ -23590,7 +23707,11 @@ function reifyCreateOperations(unit, ops) {
                 if (eventTargetResolver === undefined) {
                     throw new Error(`Unexpected global target '${op.eventTarget}' defined for '${op.name}' event. Supported list of global targets: window,document,body.`);
                 }
-                OpList.replace(op, listener(op.name, listenerFn, eventTargetResolver, op.hostListener && op.isAnimationListener, op.sourceSpan));
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly &&
+                    !op.hostListener &&
+                    !op.isLegacyAnimationListener
+                    ? domListener(op.name, listenerFn, eventTargetResolver, op.sourceSpan)
+                    : listener(op.name, listenerFn, eventTargetResolver, op.hostListener && op.isLegacyAnimationListener, op.sourceSpan));
                 break;
             case OpKind.TwoWayListener:
                 OpList.replace(op, twoWayListener(op.name, reifyListenerHandler(unit, op.handlerFnName, op.handlerOps, true), op.sourceSpan));
@@ -23748,7 +23869,7 @@ function reifyCreateOperations(unit, ops) {
         }
     }
 }
-function reifyUpdateOperations(_unit, ops) {
+function reifyUpdateOperations(unit, ops) {
     for (const op of ops) {
         transformExpressionsInOp(op, reifyIrExpression, VisitorContextFlag.None);
         switch (op.kind) {
@@ -23756,7 +23877,9 @@ function reifyUpdateOperations(_unit, ops) {
                 OpList.replace(op, advance(op.delta, op.sourceSpan));
                 break;
             case OpKind.Property:
-                OpList.replace(op, property(op.name, op.expression, op.sanitizer, op.sourceSpan));
+                OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly && !op.isLegacyAnimationTrigger
+                    ? domProperty(op.name, op.expression, op.sanitizer, op.sourceSpan)
+                    : property(op.name, op.expression, op.sanitizer, op.sourceSpan));
                 break;
             case OpKind.TwoWayProperty:
                 OpList.replace(op, twoWayProperty(op.name, op.expression, op.sanitizer, op.sourceSpan));
@@ -23790,7 +23913,7 @@ function reifyUpdateOperations(_unit, ops) {
                     throw new Error('not yet handled');
                 }
                 else {
-                    if (op.isAnimationTrigger) {
+                    if (op.isLegacyAnimationTrigger) {
                         OpList.replace(op, syntheticHostProperty(op.name, op.expression, op.sourceSpan));
                     }
                     else {
@@ -25994,8 +26117,8 @@ function isSingleI18nIcu(meta) {
  * representation.
  * TODO: Refactor more of the ingestion code into phases.
  */
-function ingestComponent(componentName, template, constantPool, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
-    const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations);
+function ingestComponent(componentName, template, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
+    const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations);
     ingestNodes(job.root, template);
     return job;
 }
@@ -26004,7 +26127,7 @@ function ingestComponent(componentName, template, constantPool, relativeContextF
  * representation.
  */
 function ingestHostBinding(input, bindingParser, constantPool) {
-    const job = new HostBindingCompilationJob(input.componentName, constantPool, compatibilityMode);
+    const job = new HostBindingCompilationJob(input.componentName, constantPool, compatibilityMode, TemplateCompilationMode.DomOnly);
     for (const property of input.properties ?? []) {
         let bindingKind = BindingKind.Property;
         // TODO: this should really be handled in the parser.
@@ -26012,8 +26135,8 @@ function ingestHostBinding(input, bindingParser, constantPool) {
             property.name = property.name.substring('attr.'.length);
             bindingKind = BindingKind.Attribute;
         }
-        if (property.isAnimation) {
-            bindingKind = BindingKind.Animation;
+        if (property.isLegacyAnimation) {
+            bindingKind = BindingKind.LegacyAnimation;
         }
         const securityContexts = bindingParser
             .calcPossibleSecurityContexts(input.componentSelector, property.name, bindingKind === BindingKind.Attribute)
@@ -26055,7 +26178,7 @@ function ingestHostAttribute(job, name, value, securityContexts) {
     job.root.update.push(attrBinding);
 }
 function ingestHostEvent(job, event) {
-    const [phase, target] = event.type !== ParsedEventType.Animation
+    const [phase, target] = event.type !== ParsedEventType.LegacyAnimation
         ? [null, event.targetOrPhase]
         : [event.targetOrPhase, null];
     const eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, makeListenerHandlerOps(job.root, event.handler, event.handlerSpan), phase, target, true, event.sourceSpan);
@@ -26680,7 +26803,7 @@ const BINDING_KINDS = new Map([
     [BindingType.Attribute, BindingKind.Attribute],
     [BindingType.Class, BindingKind.ClassName],
     [BindingType.Style, BindingKind.StyleProperty],
-    [BindingType.Animation, BindingKind.Animation],
+    [BindingType.LegacyAnimation, BindingKind.LegacyAnimation],
 ]);
 /**
  * Checks whether the given template is a plain ng-template (as opposed to another kind of template
@@ -26739,7 +26862,7 @@ function ingestElementBindings(unit, op, element) {
     unit.create.push(bindings.filter((b) => b?.kind === OpKind.ExtractedAttribute));
     unit.update.push(bindings.filter((b) => b?.kind === OpKind.Binding));
     for (const output of element.outputs) {
-        if (output.type === ParsedEventType.Animation && output.phase === null) {
+        if (output.type === ParsedEventType.LegacyAnimation && output.phase === null) {
             throw Error('Animation listener should have a phase');
         }
         if (output.type === ParsedEventType.TwoWay) {
@@ -26782,7 +26905,7 @@ function ingestTemplateBindings(unit, op, template, templateKind) {
     unit.create.push(bindings.filter((b) => b?.kind === OpKind.ExtractedAttribute));
     unit.update.push(bindings.filter((b) => b?.kind === OpKind.Binding));
     for (const output of template.outputs) {
-        if (output.type === ParsedEventType.Animation && output.phase === null) {
+        if (output.type === ParsedEventType.LegacyAnimation && output.phase === null) {
             throw Error('Animation listener should have a phase');
         }
         if (templateKind === TemplateKind.NgTemplate) {
@@ -26794,7 +26917,7 @@ function ingestTemplateBindings(unit, op, template, templateKind) {
             }
         }
         if (templateKind === TemplateKind.Structural &&
-            output.type !== ParsedEventType.Animation) {
+            output.type !== ParsedEventType.LegacyAnimation) {
             // Animation bindings are excluded from the structural template's const array.
             const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, output.name, false);
             unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, null, output.name, null, null, null, securityContext));
@@ -26852,7 +26975,8 @@ function createTemplateBinding(view, xref, type, name, value, unit, securityCont
                     return createExtractedAttributeOp(xref, BindingKind.TwoWayProperty, null, name, null, null, i18nMessage, securityContext);
             }
         }
-        if (!isTextBinding && (type === BindingType.Attribute || type === BindingType.Animation)) {
+        if (!isTextBinding &&
+            (type === BindingType.Attribute || type === BindingType.LegacyAnimation)) {
             // Again, this binding doesn't really target the ng-template; it actually targets the element
             // inside the structural template. In the case of non-text attribute or animation bindings,
             // the binding doesn't even show up on the ng-template const array, so we just skip it
@@ -27017,7 +27141,7 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
         // Note that TDB used to collect the outputs as well, but it wasn't passing them into
         // the template instruction. Here we just don't collect them.
         for (const attr of root.inputs) {
-            if (attr.type !== BindingType.Animation && attr.type !== BindingType.Attribute) {
+            if (attr.type !== BindingType.LegacyAnimation && attr.type !== BindingType.Attribute) {
                 const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
                 unit.create.push(createExtractedAttributeOp(xref, BindingKind.Property, null, attr.name, null, null, null, securityContext));
             }
@@ -27238,7 +27362,7 @@ const ATTRIBUTE_PREFIX = 'attr';
 const CLASS_PREFIX = 'class';
 const STYLE_PREFIX = 'style';
 const TEMPLATE_ATTR_PREFIX$1 = '*';
-const ANIMATE_PROP_PREFIX = 'animate-';
+const LEGACY_ANIMATE_PROP_PREFIX = 'animate-';
 /**
  * Parses bindings in templates and in the directive host area.
  */
@@ -27297,17 +27421,17 @@ class BindingParser {
         return targetEvents;
     }
     parseInterpolation(value, sourceSpan, interpolatedTokens) {
-        const sourceInfo = sourceSpan.start.toString();
         const absoluteOffset = sourceSpan.fullStart.offset;
         try {
-            const ast = this._exprParser.parseInterpolation(value, sourceInfo, absoluteOffset, interpolatedTokens, this._interpolationConfig);
-            if (ast)
-                this._reportExpressionParserErrors(ast.errors, sourceSpan);
+            const ast = this._exprParser.parseInterpolation(value, sourceSpan, absoluteOffset, interpolatedTokens, this._interpolationConfig);
+            if (ast) {
+                this.errors.push(...ast.errors);
+            }
             return ast;
         }
         catch (e) {
             this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
         }
     }
     /**
@@ -27316,17 +27440,17 @@ class BindingParser {
      * This is used for parsing the switch expression in ICUs.
      */
     parseInterpolationExpression(expression, sourceSpan) {
-        const sourceInfo = sourceSpan.start.toString();
         const absoluteOffset = sourceSpan.start.offset;
         try {
-            const ast = this._exprParser.parseInterpolationExpression(expression, sourceInfo, absoluteOffset);
-            if (ast)
-                this._reportExpressionParserErrors(ast.errors, sourceSpan);
+            const ast = this._exprParser.parseInterpolationExpression(expression, sourceSpan, absoluteOffset);
+            if (ast) {
+                this.errors.push(...ast.errors);
+            }
             return ast;
         }
         catch (e) {
             this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
         }
     }
     /**
@@ -27383,10 +27507,9 @@ class BindingParser {
      * @param absoluteValueOffset start of the `tplValue`
      */
     _parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset) {
-        const sourceInfo = sourceSpan.start.toString();
         try {
-            const bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceInfo, absoluteKeyOffset, absoluteValueOffset);
-            this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan);
+            const bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
+            bindingsResult.errors.forEach((e) => this.errors.push(e));
             bindingsResult.warnings.forEach((warning) => {
                 this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING);
             });
@@ -27398,7 +27521,7 @@ class BindingParser {
         }
     }
     parseLiteralAttr(name, value, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
-        if (isAnimationLabel(name)) {
+        if (isLegacyAnimationLabel(name)) {
             name = name.substring(1);
             if (keySpan !== undefined) {
                 keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
@@ -27407,7 +27530,7 @@ class BindingParser {
                 this._reportError(`Assigning animation triggers via @prop="exp" attributes with an expression is invalid.` +
                     ` Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`, sourceSpan, ParseErrorLevel.ERROR);
             }
-            this._parseAnimation(name, value, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+            this._parseLegacyAnimation(name, value, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
         else {
             targetProps.push(new ParsedProperty(name, this._exprParser.wrapLiteralPrimitive(value, '', absoluteOffset), ParsedPropertyType.LITERAL_ATTR, sourceSpan, keySpan, valueSpan));
@@ -27417,23 +27540,23 @@ class BindingParser {
         if (name.length === 0) {
             this._reportError(`Property name is missing in binding`, sourceSpan);
         }
-        let isAnimationProp = false;
-        if (name.startsWith(ANIMATE_PROP_PREFIX)) {
-            isAnimationProp = true;
-            name = name.substring(ANIMATE_PROP_PREFIX.length);
+        let isLegacyAnimationProp = false;
+        if (name.startsWith(LEGACY_ANIMATE_PROP_PREFIX)) {
+            isLegacyAnimationProp = true;
+            name = name.substring(LEGACY_ANIMATE_PROP_PREFIX.length);
             if (keySpan !== undefined) {
-                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + ANIMATE_PROP_PREFIX.length, keySpan.end.offset));
+                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + LEGACY_ANIMATE_PROP_PREFIX.length, keySpan.end.offset));
             }
         }
-        else if (isAnimationLabel(name)) {
-            isAnimationProp = true;
+        else if (isLegacyAnimationLabel(name)) {
+            isLegacyAnimationProp = true;
             name = name.substring(1);
             if (keySpan !== undefined) {
                 keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
             }
         }
-        if (isAnimationProp) {
-            this._parseAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+        if (isLegacyAnimationProp) {
+            this._parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
         else {
             this._parsePropertyAst(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
@@ -27451,7 +27574,7 @@ class BindingParser {
         targetMatchableAttrs.push([name, ast.source]);
         targetProps.push(new ParsedProperty(name, ast, isPartOfAssignmentBinding ? ParsedPropertyType.TWO_WAY : ParsedPropertyType.DEFAULT, sourceSpan, keySpan, valueSpan));
     }
-    _parseAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
+    _parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
         if (name.length === 0) {
             this._reportError('Animation trigger is missing', sourceSpan);
         }
@@ -27460,26 +27583,26 @@ class BindingParser {
         // states will be applied by angular when the element is attached/detached
         const ast = this.parseBinding(expression || 'undefined', false, valueSpan || sourceSpan, absoluteOffset);
         targetMatchableAttrs.push([name, ast.source]);
-        targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.ANIMATION, sourceSpan, keySpan, valueSpan));
+        targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.LEGACY_ANIMATION, sourceSpan, keySpan, valueSpan));
     }
     parseBinding(value, isHostBinding, sourceSpan, absoluteOffset) {
-        const sourceInfo = ((sourceSpan && sourceSpan.start) || '(unknown)').toString();
         try {
             const ast = isHostBinding
-                ? this._exprParser.parseSimpleBinding(value, sourceInfo, absoluteOffset, this._interpolationConfig)
-                : this._exprParser.parseBinding(value, sourceInfo, absoluteOffset, this._interpolationConfig);
-            if (ast)
-                this._reportExpressionParserErrors(ast.errors, sourceSpan);
+                ? this._exprParser.parseSimpleBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig)
+                : this._exprParser.parseBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig);
+            if (ast) {
+                this.errors.push(...ast.errors);
+            }
             return ast;
         }
         catch (e) {
             this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
         }
     }
     createBoundElementProperty(elementSelector, boundProp, skipValidation = false, mapPropertyName = true) {
-        if (boundProp.isAnimation) {
-            return new BoundElementProperty(boundProp.name, BindingType.Animation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
+        if (boundProp.isLegacyAnimation) {
+            return new BoundElementProperty(boundProp.name, BindingType.LegacyAnimation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
         }
         let unit = null;
         let bindingType = undefined;
@@ -27532,12 +27655,12 @@ class BindingParser {
         if (name.length === 0) {
             this._reportError(`Event name is missing in binding`, sourceSpan);
         }
-        if (isAnimationLabel(name)) {
+        if (isLegacyAnimationLabel(name)) {
             name = name.slice(1);
             if (keySpan !== undefined) {
                 keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
             }
-            this._parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
+            this._parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
         }
         else {
             this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
@@ -27551,14 +27674,14 @@ class BindingParser {
         const [target, eventName] = splitAtColon(rawName, [null, rawName]);
         return { eventName: eventName, target };
     }
-    parseAnimationEventName(rawName) {
+    parseLegacyAnimationEventName(rawName) {
         const matches = splitAtPeriod(rawName, [rawName, null]);
         return { eventName: matches[0], phase: matches[1] === null ? null : matches[1].toLowerCase() };
     }
-    _parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
-        const { eventName, phase } = this.parseAnimationEventName(name);
+    _parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
+        const { eventName, phase } = this.parseLegacyAnimationEventName(name);
         const ast = this._parseAction(expression, handlerSpan);
-        targetEvents.push(new ParsedEvent(eventName, phase, ParsedEventType.Animation, ast, sourceSpan, handlerSpan, keySpan));
+        targetEvents.push(new ParsedEvent(eventName, phase, ParsedEventType.LegacyAnimation, ast, sourceSpan, handlerSpan, keySpan));
         if (eventName.length === 0) {
             this._reportError(`Animation event name is missing in binding`, sourceSpan);
         }
@@ -27588,31 +27711,25 @@ class BindingParser {
         // so don't add the event name to the matchableAttrs
     }
     _parseAction(value, sourceSpan) {
-        const sourceInfo = ((sourceSpan && sourceSpan.start) || '(unknown').toString();
         const absoluteOffset = sourceSpan && sourceSpan.start ? sourceSpan.start.offset : 0;
         try {
-            const ast = this._exprParser.parseAction(value, sourceInfo, absoluteOffset, this._interpolationConfig);
+            const ast = this._exprParser.parseAction(value, sourceSpan, absoluteOffset, this._interpolationConfig);
             if (ast) {
-                this._reportExpressionParserErrors(ast.errors, sourceSpan);
+                this.errors.push(...ast.errors);
             }
             if (!ast || ast.ast instanceof EmptyExpr$1) {
                 this._reportError(`Empty expressions are not allowed`, sourceSpan);
-                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
+                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
             }
             return ast;
         }
         catch (e) {
             this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
         }
     }
-    _reportError(message, sourceSpan, level = ParseErrorLevel.ERROR, relatedError) {
-        this.errors.push(new ParseError(sourceSpan, message, level, relatedError));
-    }
-    _reportExpressionParserErrors(errors, sourceSpan) {
-        for (const error of errors) {
-            this._reportError(error.message, sourceSpan, undefined, error);
-        }
+    _reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
+        this.errors.push(new ParseError(sourceSpan, message, level));
     }
     /**
      * @param propName the name of the property / attribute
@@ -27652,7 +27769,7 @@ class BindingParser {
         return false;
     }
 }
-function isAnimationLabel(name) {
+function isLegacyAnimationLabel(name) {
     return name[0] == '@';
 }
 function calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {
@@ -29650,8 +29767,11 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         constantPool.statements.push(new DeclareVarStmt(fnName, meta.defer.dependenciesFn, undefined, StmtModifier.Final));
         allDeferrableDepsFn = variable(fnName);
     }
+    const compilationMode = meta.isStandalone && !meta.hasDirectiveDependencies
+        ? TemplateCompilationMode.DomOnly
+        : TemplateCompilationMode.Full;
     // First the template is ingested into IR:
-    const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.defer, allDeferrableDepsFn, meta.relativeTemplatePath, getTemplateSourceLocationsEnabled());
+    const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, compilationMode, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.defer, allDeferrableDepsFn, meta.relativeTemplatePath, getTemplateSourceLocationsEnabled());
     // Then the IR is transformed to prepare it for cod egeneration.
     transform(tpl, CompilationJobKind.Tmpl);
     // Finally we emit the template function:
@@ -31513,6 +31633,7 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
             declarations.push(...decl.directives.map((dir) => convertDirectiveDeclarationToMetadata(dir)));
         decl.pipes && declarations.push(...convertPipeMapToMetadata(decl.pipes));
     }
+    const hasDirectiveDependencies = declarations.every(({ kind }) => kind === R3TemplateDependencyKind.Directive || kind === R3TemplateDependencyKind.NgModule);
     return {
         ...convertDeclareDirectiveFacadeToMetadata(decl, typeSourceSpan),
         template,
@@ -31528,6 +31649,7 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
         relativeContextFilePath: '',
         i18nUseExternalIds: true,
         relativeTemplatePath: null,
+        hasDirectiveDependencies,
     };
 }
 function convertDeclarationFacadeToMetadata(declaration) {
@@ -32271,7 +32393,7 @@ class _Visitor {
         this._msgCountAtSectionStart = undefined;
     }
     _reportError(node, msg) {
-        this._errors.push(new I18nError(node.sourceSpan, msg));
+        this._errors.push(new ParseError(node.sourceSpan, msg));
     }
 }
 function _isOpeningComment(n) {
@@ -32561,7 +32683,7 @@ class XliffParser {
     visitComponent(component, context) { }
     visitDirective(directive, context) { }
     _addError(node, message) {
-        this._errors.push(new I18nError(node.sourceSpan, message));
+        this._errors.push(new ParseError(node.sourceSpan, message));
     }
 }
 // Convert ml nodes (xliff syntax) to i18n nodes
@@ -32622,7 +32744,7 @@ let XmlToI18n$2 = class XmlToI18n {
         this._addError(directive, 'Unexpected node');
     }
     _addError(node, message) {
-        this._errors.push(new I18nError(node.sourceSpan, message));
+        this._errors.push(new ParseError(node.sourceSpan, message));
     }
 };
 function getCtypeForTag(tag) {
@@ -32884,7 +33006,7 @@ class Xliff2Parser {
     visitComponent(component, context) { }
     visitDirective(directive, context) { }
     _addError(node, message) {
-        this._errors.push(new I18nError(node.sourceSpan, message));
+        this._errors.push(new ParseError(node.sourceSpan, message));
     }
 }
 // Convert ml nodes (xliff syntax) to i18n nodes
@@ -32962,7 +33084,7 @@ let XmlToI18n$1 = class XmlToI18n {
         this._addError(directive, 'Unexpected node');
     }
     _addError(node, message) {
-        this._errors.push(new I18nError(node.sourceSpan, message));
+        this._errors.push(new ParseError(node.sourceSpan, message));
     }
 };
 function getTypeForTag(tag) {
@@ -33107,7 +33229,7 @@ class XtbParser {
         this._addError(directive, 'Unexpected node');
     }
     _addError(node, message) {
-        this._errors.push(new I18nError(node.sourceSpan, message));
+        this._errors.push(new ParseError(node.sourceSpan, message));
     }
 }
 // Convert ml nodes (xtb syntax) to i18n nodes
@@ -33166,7 +33288,7 @@ class XmlToI18n {
         this._addError(directive, 'Unexpected node');
     }
     _addError(node, message) {
-        this._errors.push(new I18nError(node.sourceSpan, message));
+        this._errors.push(new ParseError(node.sourceSpan, message));
     }
 }
 
@@ -33332,7 +33454,7 @@ class I18nToHtmlVisitor {
         return text;
     }
     _addError(el, msg) {
-        this._errors.push(new I18nError(el.sourceSpan, msg));
+        this._errors.push(new ParseError(el.sourceSpan, msg));
     }
 }
 
@@ -33569,7 +33691,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.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -33587,7 +33709,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.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -33682,7 +33804,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('20.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -34098,7 +34220,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.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -34133,7 +34255,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.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -34184,7 +34306,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.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -34217,7 +34339,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.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -34268,7 +34390,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('20.1.0-next.2'));
+    definitionMap.set('version', literal('20.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -34424,7 +34546,7 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('20.1.0-next.2');
+const VERSION = new Version('20.1.0-rc.0');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -34450,5 +34572,5 @@ const VERSION = new Version('20.1.0-next.2');
 // the late binding of the Compiler to the @angular/core for jit compilation.
 publishFacade(_global);
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingPipeType, BindingType, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CombinedRecursiveAstVisitor, CommaExpr, Comment, CompilerConfig, CompilerFacadeImpl, Component, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, Directive, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, 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, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, SECURITY_SCHEMA, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, SelectorlessMatcher, 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, Component$1 as TmplAstComponent, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Directive$1 as TmplAstDirective, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HostElement as TmplAstHostElement, 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$1 as ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, 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, escapeRegExp, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, setEnableTemplateSourceLocations, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingPipeType, BindingType, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CombinedRecursiveAstVisitor, CommaExpr, Comment, CompilerConfig, CompilerFacadeImpl, Component, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, Directive, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, 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, PrefixNot, PropertyRead, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, SECURITY_SCHEMA, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, SelectorlessMatcher, 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, Component$1 as TmplAstComponent, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Directive$1 as TmplAstDirective, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HostElement as TmplAstHostElement, 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$1 as ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, 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, escapeRegExp, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, setEnableTemplateSourceLocations, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map