@angular/core 20.1.0-next.1 → 20.1.0-next.3

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

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.1.0-next.1
+ * @license Angular v20.1.0-next.3
  * (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
@@ -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;
@@ -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();
+            }
         }
-        return newOperatorToken(start, this.index, str);
+        else if (this.peek === $PERIOD) {
+            // `a?.b`
+            operator += '.';
+            this.advance();
+        }
+        return newOperatorToken(start, this.index, operator);
     }
     scanTemplateLiteralPart(start) {
         let buffer = '';
@@ -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,18 +18508,18 @@ 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 = [];
@@ -18470,23 +18527,23 @@ class Parser {
             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(input, 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 +18557,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 +18595,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 +18618,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 +18644,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 +18661,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 +18720,7 @@ var ParseContextFlags;
 })(ParseContextFlags || (ParseContextFlags = {}));
 class _ParseAST {
     input;
-    location;
+    parseSourceSpan;
     absoluteOffset;
     tokens;
     parseFlags;
@@ -18678,9 +18737,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 +18867,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 +19353,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 +19363,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 +19487,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 +19560,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 +19664,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 +19702,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 +19717,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 +20988,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 +21054,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 +21335,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 **/
@@ -22855,21 +22919,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 +22935,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 +23231,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 +23284,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 +23341,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 +23506,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 +23558,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 +23585,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.isAnimationListener
+                    ? domListener(op.name, listenerFn, eventTargetResolver, op.sourceSpan)
+                    : listener(op.name, listenerFn, eventTargetResolver, op.hostListener && op.isAnimationListener, op.sourceSpan));
                 break;
             case OpKind.TwoWayListener:
                 OpList.replace(op, twoWayListener(op.name, reifyListenerHandler(unit, op.handlerFnName, op.handlerOps, true), op.sourceSpan));
@@ -23630,7 +23747,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 +23755,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.isAnimationTrigger
+                    ? 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));
@@ -25876,8 +25995,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 +26005,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.
@@ -27173,17 +27292,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 +27311,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 +27378,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);
             });
@@ -27339,18 +27457,18 @@ class BindingParser {
         targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.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) {
@@ -27464,31 +27582,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
@@ -29526,8 +29638,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 +31422,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 +31438,7 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
         relativeContextFilePath: '',
         i18nUseExternalIds: true,
         relativeTemplatePath: null,
+        hasDirectiveDependencies,
     };
 }
 function convertDeclarationFacadeToMetadata(declaration) {
@@ -32047,7 +32164,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 +32199,7 @@ function isAttrNode(ast) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('20.1.0-next.1');
+new Version('20.1.0-next.3');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -33102,7 +33219,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-BVnpy__J.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 +37462,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 +38317,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 +38490,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 +39029,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 +39056,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 +39556,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 +40872,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;
             }
         }
@@ -44201,6 +44346,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 +44374,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 +44770,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`
@@ -47470,7 +47655,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 +47697,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 +48788,7 @@ class SymbolBuilder {
                     isStructural: meta.isStructural,
                     isInScope: true,
                     isHostDirective: false,
-                    tsCompletionEntryInfo: null,
+                    tsCompletionEntryInfos: null,
                 };
                 symbols.push(directiveSymbol);
                 seenDirectives.add(declaration);
@@ -48639,7 +48824,7 @@ class SymbolBuilder {
                     kind: exports.SymbolKind.Directive,
                     isStructural: meta.isStructural,
                     isInScope: true,
-                    tsCompletionEntryInfo: null,
+                    tsCompletionEntryInfos: null,
                 };
                 symbols.push(directiveSymbol);
                 seenDirectives.add(node);
@@ -48898,7 +49083,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 +49244,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 +49982,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 +50028,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 +50049,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 +50074,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 +50217,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 +50323,7 @@ class TemplateTypeCheckerImpl {
             selector: dep.selector,
             tsSymbol,
             ngModule,
-            tsCompletionEntryInfo: null,
+            tsCompletionEntryInfos: null,
         };
     }
     scopeDataOfPipeMeta(typeChecker, dep) {
@@ -50096,7 +50335,7 @@ class TemplateTypeCheckerImpl {
             ref: dep.ref,
             name: dep.name,
             tsSymbol,
-            tsCompletionEntryInfo: null,
+            tsCompletionEntryInfos: null,
         };
     }
 }
@@ -50277,7 +50516,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 +50538,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;