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

package/schematics/bundles/{checker-CY7a8ko8.cjs → checker-CwuJOWZI.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.1.0-next.2
+ * @license Angular v20.1.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -955,6 +955,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) {
@@ -1674,6 +1683,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;
@@ -2476,6 +2498,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',
@@ -3083,6 +3122,38 @@ class _EmittedLine {
         this.indent = indent;
     }
 }
+const BINARY_OPERATORS$4 = 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() {
@@ -3405,79 +3476,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$4.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, `)`);
@@ -3842,18 +3849,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;
@@ -4072,6 +4067,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
@@ -4402,7 +4409,7 @@ class ParsedProperty {
     keySpan;
     valueSpan;
     isLiteral;
-    isAnimation;
+    isLegacyAnimation;
     constructor(name, expression, type, sourceSpan, keySpan, valueSpan) {
         this.name = name;
         this.expression = expression;
@@ -4411,22 +4418,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 = {}));
 exports.ParsedEventType = void 0;
 (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";
 })(exports.ParsedEventType || (exports.ParsedEventType = {}));
@@ -4475,8 +4482,8 @@ exports.BindingType = void 0;
     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";
 })(exports.BindingType || (exports.BindingType = {}));
@@ -4659,7 +4666,7 @@ class BoundEvent {
     }
     static fromParsedEvent(event) {
         const target = event.type === exports.ParsedEventType.Regular ? event.targetOrPhase : null;
-        const phase = event.type === exports.ParsedEventType.Animation ? event.targetOrPhase : null;
+        const phase = event.type === exports.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}`);
         }
@@ -8785,9 +8792,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.
      */
@@ -9032,13 +9039,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,
@@ -10725,7 +10732,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 {
@@ -10738,8 +10745,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,
@@ -10994,12 +11001,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,
@@ -11021,6 +11028,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.
@@ -11029,10 +11044,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;
     /**
@@ -11057,8 +11074,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;
@@ -11203,8 +11220,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;
@@ -11436,7 +11453,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
@@ -11478,7 +11495,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, 
@@ -11588,12 +11605,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:
@@ -11637,6 +11654,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
@@ -11809,6 +11834,15 @@ const BINARY_OPERATORS$3 = 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([
@@ -15596,13 +15630,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;
@@ -15634,12 +15661,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;
@@ -15949,10 +15970,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,
@@ -15968,17 +15989,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;
@@ -16218,7 +16239,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 =
@@ -16999,7 +17020,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 {
@@ -18090,13 +18111,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:
@@ -18106,9 +18131,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();
@@ -18254,13 +18279,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();
+            }
+        }
+        else if (this.peek === $PERIOD) {
+            // `a?.b`
+            operator += '.';
             this.advance();
         }
-        return newOperatorToken(start, this.index, str);
+        return newOperatorToken(start, this.index, operator);
     }
     scanTemplateLiteralPart(start) {
         let buffer = '';
@@ -18324,6 +18359,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) ||
@@ -18384,6 +18438,9 @@ class TemplateBindingParseResult {
         this.errors = errors;
     }
 }
+function getLocation(span) {
+    return span.start.toString() || '(unknown)';
+}
 class Parser {
     _lexer;
     _supportsDirectPipeReferences;
@@ -18391,18 +18448,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();
@@ -18410,20 +18467,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
@@ -18451,42 +18508,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);
@@ -18500,7 +18561,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 = [];
@@ -18538,7 +18599,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;
@@ -18561,9 +18622,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);
@@ -18585,7 +18648,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)) {
@@ -18602,7 +18665,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));
         }
     }
     /**
@@ -18661,7 +18724,7 @@ var ParseContextFlags;
 })(ParseContextFlags || (ParseContextFlags = {}));
 class _ParseAST {
     input;
-    location;
+    parseSourceSpan;
     absoluteOffset;
     tokens;
     parseFlags;
@@ -18678,9 +18741,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;
@@ -18808,6 +18871,9 @@ class _ParseAST {
             return false;
         }
     }
+    isAssignmentOperator(token) {
+        return token.type === TokenType.Operator && Binary.isAssignmentOperation(token.strValue);
+    }
     expectOperator(operator) {
         if (this.consumeOptionalOperator(operator))
             return;
@@ -19291,7 +19357,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));
             }
@@ -19300,14 +19367,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);
@@ -19422,14 +19491,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 {
@@ -19493,7 +19564,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
@@ -19597,13 +19668,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`;
@@ -19637,7 +19706,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.
      *
@@ -19652,15 +19721,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() {
@@ -20915,7 +20992,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);
     }
@@ -20981,15 +21058,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 '*'.
@@ -21271,7 +21339,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 **/
@@ -22139,7 +22207,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;
@@ -22151,8 +22219,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) {
@@ -22420,7 +22488,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) {
@@ -22433,7 +22501,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 },
 ];
 /**
@@ -22855,21 +22923,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$1(slot),
         templateFnRef,
@@ -22885,7 +22939,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$1(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);
@@ -23151,17 +23235,7 @@ function i18nAttributes(slot, i18nAttributesConfig) {
     return call(Identifiers.i18nAttributes, args, null);
 }
 function property(name, expression, sanitizer, sourceSpan) {
-    const args = [literal$1(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$1(name), expression];
@@ -23214,6 +23288,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$1(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,
@@ -23241,11 +23345,7 @@ function i18nApply(slot, sourceSpan) {
     return call(Identifiers.i18nApply, [literal$1(slot)], sourceSpan);
 }
 function domProperty(name, expression, sanitizer, sourceSpan) {
-    const args = [literal$1(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$1(name), expression], sourceSpan);
@@ -23410,22 +23510,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));
@@ -23450,7 +23562,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());
@@ -23472,7 +23589,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));
@@ -23630,7 +23751,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) {
@@ -23638,7 +23759,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));
@@ -23672,7 +23795,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 {
@@ -25876,8 +25999,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;
 }
@@ -25886,7 +26009,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.
@@ -25894,8 +26017,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)
@@ -25937,7 +26060,7 @@ function ingestHostAttribute(job, name, value, securityContexts) {
     job.root.update.push(attrBinding);
 }
 function ingestHostEvent(job, event) {
-    const [phase, target] = event.type !== exports.ParsedEventType.Animation
+    const [phase, target] = event.type !== exports.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);
@@ -26562,7 +26685,7 @@ const BINDING_KINDS = new Map([
     [exports.BindingType.Attribute, BindingKind.Attribute],
     [exports.BindingType.Class, BindingKind.ClassName],
     [exports.BindingType.Style, BindingKind.StyleProperty],
-    [exports.BindingType.Animation, BindingKind.Animation],
+    [exports.BindingType.LegacyAnimation, BindingKind.LegacyAnimation],
 ]);
 /**
  * Checks whether the given template is a plain ng-template (as opposed to another kind of template
@@ -26621,7 +26744,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 === exports.ParsedEventType.Animation && output.phase === null) {
+        if (output.type === exports.ParsedEventType.LegacyAnimation && output.phase === null) {
             throw Error('Animation listener should have a phase');
         }
         if (output.type === exports.ParsedEventType.TwoWay) {
@@ -26664,7 +26787,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 === exports.ParsedEventType.Animation && output.phase === null) {
+        if (output.type === exports.ParsedEventType.LegacyAnimation && output.phase === null) {
             throw Error('Animation listener should have a phase');
         }
         if (templateKind === TemplateKind.NgTemplate) {
@@ -26676,7 +26799,7 @@ function ingestTemplateBindings(unit, op, template, templateKind) {
             }
         }
         if (templateKind === TemplateKind.Structural &&
-            output.type !== exports.ParsedEventType.Animation) {
+            output.type !== exports.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));
@@ -26734,7 +26857,8 @@ function createTemplateBinding(view, xref, type, name, value, unit, securityCont
                     return createExtractedAttributeOp(xref, BindingKind.TwoWayProperty, null, name, null, null, i18nMessage, securityContext);
             }
         }
-        if (!isTextBinding && (type === exports.BindingType.Attribute || type === exports.BindingType.Animation)) {
+        if (!isTextBinding &&
+            (type === exports.BindingType.Attribute || type === exports.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
@@ -26899,7 +27023,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 !== exports.BindingType.Animation && attr.type !== exports.BindingType.Attribute) {
+            if (attr.type !== exports.BindingType.LegacyAnimation && attr.type !== exports.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));
             }
@@ -27114,7 +27238,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.
  */
@@ -27173,17 +27297,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);
         }
     }
     /**
@@ -27192,17 +27316,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);
         }
     }
     /**
@@ -27259,10 +27383,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);
             });
@@ -27274,7 +27397,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));
@@ -27283,7 +27406,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));
@@ -27293,23 +27416,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);
@@ -27327,7 +27450,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);
         }
@@ -27336,26 +27459,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, exports.BindingType.Animation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
+        if (boundProp.isLegacyAnimation) {
+            return new BoundElementProperty(boundProp.name, exports.BindingType.LegacyAnimation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
         }
         let unit = null;
         let bindingType = undefined;
@@ -27408,12 +27531,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);
@@ -27427,14 +27550,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, exports.ParsedEventType.Animation, ast, sourceSpan, handlerSpan, keySpan));
+        targetEvents.push(new ParsedEvent(eventName, phase, exports.ParsedEventType.LegacyAnimation, ast, sourceSpan, handlerSpan, keySpan));
         if (eventName.length === 0) {
             this._reportError(`Animation event name is missing in binding`, sourceSpan);
         }
@@ -27464,31 +27587,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
@@ -27528,7 +27645,7 @@ class BindingParser {
         return false;
     }
 }
-function isAnimationLabel(name) {
+function isLegacyAnimationLabel(name) {
     return name[0] == '@';
 }
 function calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {
@@ -29526,8 +29643,11 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         constantPool.statements.push(new DeclareVarStmt(fnName, meta.defer.dependenciesFn, undefined, exports.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:
@@ -31307,6 +31427,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 === exports.R3TemplateDependencyKind.Directive || kind === exports.R3TemplateDependencyKind.NgModule);
     return {
         ...convertDeclareDirectiveFacadeToMetadata(decl, typeSourceSpan),
         template,
@@ -31322,6 +31443,7 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
         relativeContextFilePath: '',
         i18nUseExternalIds: true,
         relativeTemplatePath: null,
+        hasDirectiveDependencies,
     };
 }
 function convertDeclarationFacadeToMetadata(declaration) {
@@ -32047,7 +32169,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) {
@@ -32082,7 +32204,7 @@ function isAttrNode(ast) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('20.1.0-next.2');
+new Version('20.1.0-rc.0');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -33102,7 +33224,7 @@ class NodeJSPathManipulation {
 // G3-ESM-MARKER: G3 uses CommonJS, but externally everything in ESM.
 // CommonJS/ESM interop for determining the current file name and containing dir.
 const isCommonJS = typeof __filename !== 'undefined';
-const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('checker-CY7a8ko8.cjs', document.baseURI).href));
+const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('checker-CwuJOWZI.cjs', document.baseURI).href));
 const currentFileName = isCommonJS ? __filename : url.fileURLToPath(currentFileUrl);
 /**
  * A wrapper around the Node.js file-system that supports readonly operations and path manipulation.
@@ -37345,26 +37467,30 @@ exports.PerfPhase = void 0;
      * Time spent by the Angular Language Service calculating outlining spans.
      */
     PerfPhase[PerfPhase["OutliningSpans"] = 24] = "OutliningSpans";
-    /**
-     * Tracks the number of `PerfPhase`s, and must appear at the end of the list.
-     */
-    PerfPhase[PerfPhase["LAST"] = 25] = "LAST";
     /**
      * Time spent by the Angular Language Service calculating code fixes.
      */
-    PerfPhase[PerfPhase["LsCodeFixes"] = 26] = "LsCodeFixes";
+    PerfPhase[PerfPhase["LsCodeFixes"] = 25] = "LsCodeFixes";
     /**
      * Time spent by the Angular Language Service to fix all detected same type errors.
      */
-    PerfPhase[PerfPhase["LsCodeFixesAll"] = 27] = "LsCodeFixesAll";
+    PerfPhase[PerfPhase["LsCodeFixesAll"] = 26] = "LsCodeFixesAll";
     /**
      * Time spent computing possible Angular refactorings.
      */
-    PerfPhase[PerfPhase["LSComputeApplicableRefactorings"] = 28] = "LSComputeApplicableRefactorings";
+    PerfPhase[PerfPhase["LSComputeApplicableRefactorings"] = 27] = "LSComputeApplicableRefactorings";
     /**
      * Time spent computing changes for applying a given refactoring.
      */
-    PerfPhase[PerfPhase["LSApplyRefactoring"] = 29] = "LSApplyRefactoring";
+    PerfPhase[PerfPhase["LSApplyRefactoring"] = 28] = "LSApplyRefactoring";
+    /**
+     * Time spent by the Angular Language Service calculating semantic classifications.
+     */
+    PerfPhase[PerfPhase["LSSemanticClassification"] = 29] = "LSSemanticClassification";
+    /**
+     * Tracks the number of `PerfPhase`s, and must appear at the end of the list.
+     */
+    PerfPhase[PerfPhase["LAST"] = 30] = "LAST";
 })(exports.PerfPhase || (exports.PerfPhase = {}));
 /**
  * Represents some occurrence during compilation, and is tracked with a counter.
@@ -38196,6 +38322,16 @@ const BINARY_OPERATORS$1 = /* @__PURE__ */ new Map([
     [BinaryOperator.NullishCoalesce, '??'],
     [BinaryOperator.Exponentiation, '**'],
     [BinaryOperator.In, 'in'],
+    [BinaryOperator.Assign, '='],
+    [BinaryOperator.AdditionAssignment, '+='],
+    [BinaryOperator.SubtractionAssignment, '-='],
+    [BinaryOperator.MultiplicationAssignment, '*='],
+    [BinaryOperator.DivisionAssignment, '/='],
+    [BinaryOperator.RemainderAssignment, '%='],
+    [BinaryOperator.ExponentiationAssignment, '**='],
+    [BinaryOperator.AndAssignment, '&&='],
+    [BinaryOperator.OrAssignment, '||='],
+    [BinaryOperator.NullishCoalesceAssignment, '??='],
 ]);
 class ExpressionTranslatorVisitor {
     factory;
@@ -38359,13 +38495,14 @@ class ExpressionTranslatorVisitor {
             : ast.body.visitExpression(this, context));
     }
     visitBinaryOperatorExpr(ast, context) {
-        if (ast.operator === BinaryOperator.Assign) {
-            return this.factory.createAssignment(ast.lhs.visitExpression(this, context), ast.rhs.visitExpression(this, context));
-        }
         if (!BINARY_OPERATORS$1.has(ast.operator)) {
             throw new Error(`Unknown binary operator: ${BinaryOperator[ast.operator]}`);
         }
-        return this.factory.createBinaryExpression(ast.lhs.visitExpression(this, context), BINARY_OPERATORS$1.get(ast.operator), ast.rhs.visitExpression(this, context));
+        const operator = BINARY_OPERATORS$1.get(ast.operator);
+        if (ast.isAssignment()) {
+            return this.factory.createAssignment(ast.lhs.visitExpression(this, context), operator, ast.rhs.visitExpression(this, context));
+        }
+        return this.factory.createBinaryExpression(ast.lhs.visitExpression(this, context), operator, ast.rhs.visitExpression(this, context));
     }
     visitReadPropExpr(ast, context) {
         return this.factory.createPropertyAccess(ast.receiver.visitExpression(this, context), ast.name);
@@ -38897,6 +39034,16 @@ const BINARY_OPERATORS = /* @__PURE__ */ (() => ({
     '+': ts.SyntaxKind.PlusToken,
     '??': ts.SyntaxKind.QuestionQuestionToken,
     'in': ts.SyntaxKind.InKeyword,
+    '=': ts.SyntaxKind.EqualsToken,
+    '+=': ts.SyntaxKind.PlusEqualsToken,
+    '-=': ts.SyntaxKind.MinusEqualsToken,
+    '*=': ts.SyntaxKind.AsteriskEqualsToken,
+    '/=': ts.SyntaxKind.SlashEqualsToken,
+    '%=': ts.SyntaxKind.PercentEqualsToken,
+    '**=': ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    '&&=': ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    '||=': ts.SyntaxKind.BarBarEqualsToken,
+    '??=': ts.SyntaxKind.QuestionQuestionEqualsToken,
 }))();
 const VAR_TYPES = /* @__PURE__ */ (() => ({
     'const': ts.NodeFlags.Const,
@@ -38914,8 +39061,8 @@ class TypeScriptAstFactory {
     }
     attachComments = attachComments;
     createArrayLiteral = ts.factory.createArrayLiteralExpression;
-    createAssignment(target, value) {
-        return ts.factory.createBinaryExpression(target, ts.SyntaxKind.EqualsToken, value);
+    createAssignment(target, operator, value) {
+        return ts.factory.createBinaryExpression(target, BINARY_OPERATORS[operator], value);
     }
     createBinaryExpression(leftOperand, operator, rightOperand) {
         return ts.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS[operator], rightOperand);
@@ -39414,6 +39561,9 @@ function validateAccessOfInitializerApiMember({ api, call }, member) {
  * @returns The parsed initializer API, or null if none was found.
  */
 function tryParseInitializerApi(functions, expression, reflector, importTracker) {
+    if (ts.isAsExpression(expression) || ts.isParenthesizedExpression(expression)) {
+        return tryParseInitializerApi(functions, expression.expression, reflector, importTracker);
+    }
     if (!ts.isCallExpression(expression)) {
         return null;
     }
@@ -40727,11 +40877,11 @@ function getHostBindingErrorNode(error, hostExpr) {
     // confidently match the error to its expression by looking at the string value that the parser
     // failed to parse and the initializers for each of the properties. If we fail to match, we fall
     // back to the old behavior where the error is reported on the entire `host` object.
-    if (ts.isObjectLiteralExpression(hostExpr) && error.relatedError instanceof ParserError) {
+    if (ts.isObjectLiteralExpression(hostExpr)) {
         for (const prop of hostExpr.properties) {
             if (ts.isPropertyAssignment(prop) &&
                 ts.isStringLiteralLike(prop.initializer) &&
-                prop.initializer.text === error.relatedError.input) {
+                error.msg.includes(`[${prop.initializer.text}]`)) {
                 return prop.initializer;
             }
         }
@@ -41560,97 +41710,88 @@ class CompletionEngine {
     }
 }
 
-const comma = ','.charCodeAt(0);
-const semicolon = ';'.charCodeAt(0);
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
 for (let i = 0; i < chars.length; i++) {
-    const c = chars.charCodeAt(i);
-    intToChar[i] = c;
-    charToInt[c] = i;
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
 }
 function encodeInteger(builder, num, relative) {
-    let delta = num - relative;
-    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
-    do {
-        let clamped = delta & 0b011111;
-        delta >>>= 5;
-        if (delta > 0)
-            clamped |= 0b100000;
-        builder.write(intToChar[clamped]);
-    } while (delta > 0);
-    return num;
-}
-
-const bufLength = 1024 * 16;
-// Provide a fallback for older environments.
-const td = typeof TextDecoder !== 'undefined'
-    ? /* #__PURE__ */ new TextDecoder()
-    : typeof Buffer !== 'undefined'
-        ? {
-            decode(buf) {
-                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
-                return out.toString();
-            },
-        }
-        : {
-            decode(buf) {
-                let out = '';
-                for (let i = 0; i < buf.length; i++) {
-                    out += String.fromCharCode(buf[i]);
-                }
-                return out;
-            },
-        };
-class StringWriter {
-    constructor() {
-        this.pos = 0;
-        this.out = '';
-        this.buffer = new Uint8Array(bufLength);
-    }
-    write(v) {
-        const { buffer } = this;
-        buffer[this.pos++] = v;
-        if (this.pos === bufLength) {
-            this.out += td.decode(buffer);
-            this.pos = 0;
-        }
-    }
-    flush() {
-        const { buffer, out, pos } = this;
-        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  let delta = num - relative;
+  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+  do {
+    let clamped = delta & 31;
+    delta >>>= 5;
+    if (delta > 0) clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (delta > 0);
+  return num;
+}
+
+// src/strings.ts
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+  decode(buf) {
+    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    return out.toString();
+  }
+} : {
+  decode(buf) {
+    let out = "";
+    for (let i = 0; i < buf.length; i++) {
+      out += String.fromCharCode(buf[i]);
     }
-}
+    return out;
+  }
+};
+var StringWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.out = "";
+    this.buffer = new Uint8Array(bufLength);
+  }
+  write(v) {
+    const { buffer } = this;
+    buffer[this.pos++] = v;
+    if (this.pos === bufLength) {
+      this.out += td.decode(buffer);
+      this.pos = 0;
+    }
+  }
+  flush() {
+    const { buffer, out, pos } = this;
+    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  }
+};
 function encode(decoded) {
-    const writer = new StringWriter();
-    let sourcesIndex = 0;
-    let sourceLine = 0;
-    let sourceColumn = 0;
-    let namesIndex = 0;
-    for (let i = 0; i < decoded.length; i++) {
-        const line = decoded[i];
-        if (i > 0)
-            writer.write(semicolon);
-        if (line.length === 0)
-            continue;
-        let genColumn = 0;
-        for (let j = 0; j < line.length; j++) {
-            const segment = line[j];
-            if (j > 0)
-                writer.write(comma);
-            genColumn = encodeInteger(writer, segment[0], genColumn);
-            if (segment.length === 1)
-                continue;
-            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
-            sourceLine = encodeInteger(writer, segment[2], sourceLine);
-            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
-            if (segment.length === 4)
-                continue;
-            namesIndex = encodeInteger(writer, segment[4], namesIndex);
-        }
-    }
-    return writer.flush();
+  const writer = new StringWriter();
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0) writer.write(semicolon);
+    if (line.length === 0) continue;
+    let genColumn = 0;
+    for (let j = 0; j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0) writer.write(comma);
+      genColumn = encodeInteger(writer, segment[0], genColumn);
+      if (segment.length === 1) continue;
+      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+      sourceLine = encodeInteger(writer, segment[2], sourceLine);
+      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      if (segment.length === 4) continue;
+      namesIndex = encodeInteger(writer, segment[4], namesIndex);
+    }
+  }
+  return writer.flush();
 }
 
 class BitSet {
@@ -43538,8 +43679,8 @@ function createNodeFromListenerDecorator(decorator, parser, listeners) {
     let phase;
     let target;
     if (eventNameNode.text.startsWith('@')) {
-        const parsedName = parser.parseAnimationEventName(eventNameNode.text);
-        type = exports.ParsedEventType.Animation;
+        const parsedName = parser.parseLegacyAnimationEventName(eventNameNode.text);
+        type = exports.ParsedEventType.LegacyAnimation;
         eventName = parsedName.eventName;
         phase = parsedName.phase;
         target = null;
@@ -43579,7 +43720,7 @@ function inferBoundAttribute(name) {
     }
     else if (name.startsWith(animationPrefix)) {
         attrName = name.slice(animationPrefix.length);
-        type = exports.BindingType.Animation;
+        type = exports.BindingType.LegacyAnimation;
     }
     else {
         attrName = name;
@@ -44201,6 +44342,22 @@ class OutOfBandDiagnosticRecorderImpl {
      * is ever produced per node.
      */
     recordedPipes = new Set();
+    /** Common pipes that can be suggested to users. */
+    pipeSuggestions = new Map([
+        ['async', 'AsyncPipe'],
+        ['uppercase', 'UpperCasePipe'],
+        ['lowercase', 'LowerCasePipe'],
+        ['json', 'JsonPipe'],
+        ['slice', 'SlicePipe'],
+        ['number', 'DecimalPipe'],
+        ['percent', 'PercentPipe'],
+        ['titlecase', 'TitleCasePipe'],
+        ['currency', 'CurrencyPipe'],
+        ['date', 'DatePipe'],
+        ['i18nPlural', 'I18nPluralPipe'],
+        ['i18nSelect', 'I18nSelectPipe'],
+        ['keyvalue', 'KeyValuePipe'],
+    ]);
     constructor(resolver) {
         this.resolver = resolver;
     }
@@ -44213,16 +44370,30 @@ class OutOfBandDiagnosticRecorderImpl {
         const errorMsg = `No directive found with exportAs '${value}'.`;
         this._diagnostics.push(makeTemplateDiagnostic(id, mapping, ref.valueSpan || ref.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.MISSING_REFERENCE_TARGET), errorMsg));
     }
-    missingPipe(id, ast) {
+    missingPipe(id, ast, isStandalone) {
         if (this.recordedPipes.has(ast)) {
             return;
         }
-        const mapping = this.resolver.getTemplateSourceMapping(id);
-        const errorMsg = `No pipe found with name '${ast.name}'.`;
         const sourceSpan = this.resolver.toTemplateParseSourceSpan(id, ast.nameSpan);
         if (sourceSpan === null) {
             throw new Error(`Assertion failure: no SourceLocation found for usage of pipe '${ast.name}'.`);
         }
+        const mapping = this.resolver.getTemplateSourceMapping(id);
+        let errorMsg = `No pipe found with name '${ast.name}'.`;
+        if (this.pipeSuggestions.has(ast.name)) {
+            const suggestedClassName = this.pipeSuggestions.get(ast.name);
+            const suggestedImport = '@angular/common';
+            if (isStandalone) {
+                errorMsg +=
+                    `\nTo fix this, import the "${suggestedClassName}" class from "${suggestedImport}"` +
+                        ` and add it to the "imports" array of the component.`;
+            }
+            else {
+                errorMsg +=
+                    `\nTo fix this, import the "${suggestedClassName}" class from "${suggestedImport}"` +
+                        ` and add it to the "imports" array of the module declaring the component.`;
+            }
+        }
         this._diagnostics.push(makeTemplateDiagnostic(id, mapping, sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.MISSING_PIPE), errorMsg));
         this.recordedPipes.add(ast);
     }
@@ -44595,6 +44766,16 @@ const BINARY_OPS = new Map([
     ['|', ts.SyntaxKind.BarToken],
     ['??', ts.SyntaxKind.QuestionQuestionToken],
     ['in', ts.SyntaxKind.InKeyword],
+    ['=', ts.SyntaxKind.EqualsToken],
+    ['+=', ts.SyntaxKind.PlusEqualsToken],
+    ['-=', ts.SyntaxKind.MinusEqualsToken],
+    ['*=', ts.SyntaxKind.AsteriskEqualsToken],
+    ['/=', ts.SyntaxKind.SlashEqualsToken],
+    ['%=', ts.SyntaxKind.PercentEqualsToken],
+    ['**=', ts.SyntaxKind.AsteriskAsteriskEqualsToken],
+    ['&&=', ts.SyntaxKind.AmpersandAmpersandEqualsToken],
+    ['||=', ts.SyntaxKind.BarBarEqualsToken],
+    ['??=', ts.SyntaxKind.QuestionQuestionEqualsToken],
 ]);
 /**
  * Convert an `AST` to TypeScript code directly, without going through an intermediate `Expression`
@@ -46167,7 +46348,7 @@ class TcbDirectiveOutputsOp extends TcbOp {
         let dirId = null;
         const outputs = this.dir.outputs;
         for (const output of this.node.outputs) {
-            if (output.type === exports.ParsedEventType.Animation ||
+            if (output.type === exports.ParsedEventType.LegacyAnimation ||
                 !outputs.hasBindingPropertyName(output.name)) {
                 continue;
             }
@@ -46252,7 +46433,7 @@ class TcbUnclaimedOutputsOp extends TcbOp {
                     continue;
                 }
             }
-            if (output.type === exports.ParsedEventType.Animation) {
+            if (output.type === exports.ParsedEventType.LegacyAnimation) {
                 // Animation output bindings always have an `$event` parameter of type `AnimationEvent`.
                 const eventType = this.tcb.env.config.checkTypeOfAnimationEvents
                     ? this.tcb.env.referenceExternalType('@angular/animations', 'AnimationEvent')
@@ -47470,7 +47651,7 @@ class TcbExpressionTranslator {
             return targetExpression;
         }
         else if (ast instanceof Binary &&
-            ast.operation === '=' &&
+            Binary.isAssignmentOperation(ast.operation) &&
             ast.left instanceof PropertyRead &&
             ast.left.receiver instanceof ImplicitReceiver) {
             const read = ast.left;
@@ -47512,7 +47693,7 @@ class TcbExpressionTranslator {
             let pipe;
             if (pipeMeta === null) {
                 // No pipe by that name exists in scope. Record this as an error.
-                this.tcb.oobRecorder.missingPipe(this.tcb.id, ast);
+                this.tcb.oobRecorder.missingPipe(this.tcb.id, ast, this.tcb.hostIsStandalone);
                 // Use an 'any' value to at least allow the rest of the expression to be checked.
                 pipe = ANY_EXPRESSION;
             }
@@ -48603,7 +48784,7 @@ class SymbolBuilder {
                     isStructural: meta.isStructural,
                     isInScope: true,
                     isHostDirective: false,
-                    tsCompletionEntryInfo: null,
+                    tsCompletionEntryInfos: null,
                 };
                 symbols.push(directiveSymbol);
                 seenDirectives.add(declaration);
@@ -48639,7 +48820,7 @@ class SymbolBuilder {
                     kind: exports.SymbolKind.Directive,
                     isStructural: meta.isStructural,
                     isInScope: true,
-                    tsCompletionEntryInfo: null,
+                    tsCompletionEntryInfos: null,
                 };
                 symbols.push(directiveSymbol);
                 seenDirectives.add(node);
@@ -48898,7 +49079,7 @@ class SymbolBuilder {
             ngModule,
             isHostDirective: false,
             isInScope: true, // TODO: this should always be in scope in this context, right?
-            tsCompletionEntryInfo: null,
+            tsCompletionEntryInfos: null,
         };
     }
     getSymbolOfVariable(variable) {
@@ -49059,7 +49240,7 @@ class SymbolBuilder {
         // AST so there is no way to retrieve a `Symbol` for just the `name` via a specific node.
         // Also skipping SafePropertyReads as it breaks nullish coalescing not nullable extended diagnostic
         if (expression instanceof Binary &&
-            expression.operation === '=' &&
+            Binary.isAssignmentOperation(expression.operation) &&
             expression.left instanceof PropertyRead) {
             withSpan = expression.left.nameSpan;
         }
@@ -49797,7 +49978,11 @@ class TemplateTypeCheckerImpl {
         return {
             ...withScope,
             isInScope,
-            tsCompletionEntryInfo,
+            /**
+             * The Angular LS only supports displaying one directive at a time when
+             * providing the completion item, even if it's exported by multiple modules.
+             */
+            tsCompletionEntryInfos: tsCompletionEntryInfo !== null ? [tsCompletionEntryInfo] : null,
         };
     }
     getElementsInFileScope(component) {
@@ -49839,7 +50024,8 @@ class TemplateTypeCheckerImpl {
         const currentComponentFileName = component.getSourceFile().fileName;
         for (const { symbol, data } of entries ?? []) {
             const symbolFileName = symbol?.declarations?.[0]?.getSourceFile().fileName;
-            if (symbolFileName === undefined) {
+            const symbolName = symbol?.name;
+            if (symbolFileName === undefined || symbolName === undefined) {
                 continue;
             }
             if (symbolFileName === currentComponentFileName) {
@@ -49859,23 +50045,22 @@ class TemplateTypeCheckerImpl {
                 });
             }
             else {
-                const ngModuleMeta = this.metaReader.getNgModuleMetadata(ref);
-                if (ngModuleMeta === null) {
-                    continue;
-                }
-                for (const moduleExports of ngModuleMeta.exports) {
-                    const directiveMeta = this.metaReader.getDirectiveMetadata(moduleExports);
-                    if (directiveMeta === null) {
-                        continue;
-                    }
-                    directiveDecls.push({
-                        meta: directiveMeta,
-                        ref: moduleExports,
-                    });
-                }
+                const directiveDeclsForNgModule = this.getDirectiveDeclsForNgModule(ref);
+                directiveDecls.push(...directiveDeclsForNgModule);
             }
             for (const directiveDecl of directiveDecls) {
+                const cachedCompletionEntryInfos = resultingDirectives.get(directiveDecl.ref.node)?.tsCompletionEntryInfos ?? [];
+                cachedCompletionEntryInfos.push({
+                    tsCompletionEntryData: data,
+                    tsCompletionEntrySymbolFileName: symbolFileName,
+                    tsCompletionEntrySymbolName: symbolName,
+                });
                 if (resultingDirectives.has(directiveDecl.ref.node)) {
+                    const directiveInfo = resultingDirectives.get(directiveDecl.ref.node);
+                    resultingDirectives.set(directiveDecl.ref.node, {
+                        ...directiveInfo,
+                        tsCompletionEntryInfos: cachedCompletionEntryInfos,
+                    });
                     continue;
                 }
                 const withScope = this.scopeDataOfDirectiveMeta(typeChecker, directiveDecl.meta);
@@ -49885,15 +50070,41 @@ class TemplateTypeCheckerImpl {
                 resultingDirectives.set(directiveDecl.ref.node, {
                     ...withScope,
                     isInScope: false,
-                    tsCompletionEntryInfo: {
-                        tsCompletionEntryData: data,
-                        tsCompletionEntrySymbolFileName: symbolFileName,
-                    },
+                    tsCompletionEntryInfos: cachedCompletionEntryInfos,
                 });
             }
         }
         return Array.from(resultingDirectives.values());
     }
+    /**
+     * If the NgModule exports a new module, we need to recursively get its directives.
+     */
+    getDirectiveDeclsForNgModule(ref) {
+        const ngModuleMeta = this.metaReader.getNgModuleMetadata(ref);
+        if (ngModuleMeta === null) {
+            return [];
+        }
+        const directiveDecls = [];
+        for (const moduleExports of ngModuleMeta.exports) {
+            const directiveMeta = this.metaReader.getDirectiveMetadata(moduleExports);
+            if (directiveMeta !== null) {
+                directiveDecls.push({
+                    meta: directiveMeta,
+                    ref: moduleExports,
+                });
+            }
+            else {
+                const ngModuleMeta = this.metaReader.getNgModuleMetadata(moduleExports);
+                if (ngModuleMeta === null) {
+                    continue;
+                }
+                // If the export is an NgModule, we need to recursively get its directives.
+                const nestedDirectiveDecls = this.getDirectiveDeclsForNgModule(moduleExports);
+                directiveDecls.push(...nestedDirectiveDecls);
+            }
+        }
+        return directiveDecls;
+    }
     getPotentialElementTags(component, tsLs, options) {
         if (this.elementTagCache.has(component)) {
             return this.elementTagCache.get(component);
@@ -50002,27 +50213,51 @@ class TemplateTypeCheckerImpl {
         }
         return null;
     }
-    getPotentialImportsFor(toImport, inContext, importMode) {
+    getPotentialImportsFor(toImport, inContext, importMode, potentialDirectiveModuleSpecifierResolver) {
         const imports = [];
         const meta = this.metaReader.getDirectiveMetadata(toImport) ?? this.metaReader.getPipeMetadata(toImport);
         if (meta === null) {
             return imports;
         }
+        /**
+         * When providing completion items, the Angular Language Service only supports displaying
+         * one directive at a time. If a directive is exported by two different modules,
+         * the Language Service will select the first module. To ensure the most appropriate directive
+         * is shown, move the likely one to the top of the import list.
+         *
+         * When providing the code action for the directive. All the imports will show for the developer to choose.
+         */
+        let highestImportPriority = -1;
+        const collectImports = (emit, moduleSpecifier) => {
+            if (emit === null) {
+                return;
+            }
+            imports.push({
+                ...emit,
+                moduleSpecifier: moduleSpecifier ?? emit.moduleSpecifier,
+            });
+            if (moduleSpecifier !== undefined && highestImportPriority === -1) {
+                highestImportPriority = imports.length - 1;
+            }
+        };
         if (meta.isStandalone || importMode === exports.PotentialImportMode.ForceDirect) {
             const emitted = this.emit(exports.PotentialImportKind.Standalone, toImport, inContext);
-            if (emitted !== null) {
-                imports.push(emitted);
-            }
+            const moduleSpecifier = potentialDirectiveModuleSpecifierResolver?.resolve(toImport, inContext);
+            collectImports(emitted, moduleSpecifier);
         }
         const exportingNgModules = this.ngModuleIndex.getNgModulesExporting(meta.ref.node);
         if (exportingNgModules !== null) {
             for (const exporter of exportingNgModules) {
                 const emittedRef = this.emit(exports.PotentialImportKind.NgModule, exporter, inContext);
-                if (emittedRef !== null) {
-                    imports.push(emittedRef);
-                }
+                const moduleSpecifier = potentialDirectiveModuleSpecifierResolver?.resolve(exporter, inContext);
+                collectImports(emittedRef, moduleSpecifier);
             }
         }
+        // move the import with module specifier from the tsLs to top in the imports array
+        if (highestImportPriority > 0) {
+            const highImport = imports.splice(highestImportPriority, 1)[0];
+            imports.unshift(highImport);
+        }
         return imports;
     }
     getComponentScope(component) {
@@ -50084,7 +50319,7 @@ class TemplateTypeCheckerImpl {
             selector: dep.selector,
             tsSymbol,
             ngModule,
-            tsCompletionEntryInfo: null,
+            tsCompletionEntryInfos: null,
         };
     }
     scopeDataOfPipeMeta(typeChecker, dep) {
@@ -50096,7 +50331,7 @@ class TemplateTypeCheckerImpl {
             ref: dep.ref,
             name: dep.name,
             tsSymbol,
-            tsCompletionEntryInfo: null,
+            tsCompletionEntryInfos: null,
         };
     }
 }
@@ -50277,7 +50512,6 @@ exports.FnParam = FnParam;
 exports.ForLoopBlock = ForLoopBlock;
 exports.FunctionExpr = FunctionExpr;
 exports.HtmlParser = HtmlParser;
-exports.I18nError = I18nError;
 exports.INPUT_INITIALIZER_FN = INPUT_INITIALIZER_FN;
 exports.Icu = Icu;
 exports.IcuPlaceholder = IcuPlaceholder;
@@ -50300,6 +50534,7 @@ exports.NULL_EXPR = NULL_EXPR;
 exports.NgOriginalFile = NgOriginalFile;
 exports.NodeJSFileSystem = NodeJSFileSystem;
 exports.OUTPUT_INITIALIZER_FNS = OUTPUT_INITIALIZER_FNS;
+exports.ParseError = ParseError;
 exports.ParseLocation = ParseLocation;
 exports.ParseSourceFile = ParseSourceFile;
 exports.ParseSourceSpan = ParseSourceSpan;