@angular/core 20.0.1 → 20.1.0-next.0

package/schematics/bundles/{checker-Bu1Wu4f7.cjs → checker-CuQvkMhs.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.0.1
+ * @license Angular v20.1.0-next.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -936,24 +936,25 @@ var BinaryOperator;
 (function (BinaryOperator) {
     BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals";
     BinaryOperator[BinaryOperator["NotEquals"] = 1] = "NotEquals";
-    BinaryOperator[BinaryOperator["Identical"] = 2] = "Identical";
-    BinaryOperator[BinaryOperator["NotIdentical"] = 3] = "NotIdentical";
-    BinaryOperator[BinaryOperator["Minus"] = 4] = "Minus";
-    BinaryOperator[BinaryOperator["Plus"] = 5] = "Plus";
-    BinaryOperator[BinaryOperator["Divide"] = 6] = "Divide";
-    BinaryOperator[BinaryOperator["Multiply"] = 7] = "Multiply";
-    BinaryOperator[BinaryOperator["Modulo"] = 8] = "Modulo";
-    BinaryOperator[BinaryOperator["And"] = 9] = "And";
-    BinaryOperator[BinaryOperator["Or"] = 10] = "Or";
-    BinaryOperator[BinaryOperator["BitwiseOr"] = 11] = "BitwiseOr";
-    BinaryOperator[BinaryOperator["BitwiseAnd"] = 12] = "BitwiseAnd";
-    BinaryOperator[BinaryOperator["Lower"] = 13] = "Lower";
-    BinaryOperator[BinaryOperator["LowerEquals"] = 14] = "LowerEquals";
-    BinaryOperator[BinaryOperator["Bigger"] = 15] = "Bigger";
-    BinaryOperator[BinaryOperator["BiggerEquals"] = 16] = "BiggerEquals";
-    BinaryOperator[BinaryOperator["NullishCoalesce"] = 17] = "NullishCoalesce";
-    BinaryOperator[BinaryOperator["Exponentiation"] = 18] = "Exponentiation";
-    BinaryOperator[BinaryOperator["In"] = 19] = "In";
+    BinaryOperator[BinaryOperator["Assign"] = 2] = "Assign";
+    BinaryOperator[BinaryOperator["Identical"] = 3] = "Identical";
+    BinaryOperator[BinaryOperator["NotIdentical"] = 4] = "NotIdentical";
+    BinaryOperator[BinaryOperator["Minus"] = 5] = "Minus";
+    BinaryOperator[BinaryOperator["Plus"] = 6] = "Plus";
+    BinaryOperator[BinaryOperator["Divide"] = 7] = "Divide";
+    BinaryOperator[BinaryOperator["Multiply"] = 8] = "Multiply";
+    BinaryOperator[BinaryOperator["Modulo"] = 9] = "Modulo";
+    BinaryOperator[BinaryOperator["And"] = 10] = "And";
+    BinaryOperator[BinaryOperator["Or"] = 11] = "Or";
+    BinaryOperator[BinaryOperator["BitwiseOr"] = 12] = "BitwiseOr";
+    BinaryOperator[BinaryOperator["BitwiseAnd"] = 13] = "BitwiseAnd";
+    BinaryOperator[BinaryOperator["Lower"] = 14] = "Lower";
+    BinaryOperator[BinaryOperator["LowerEquals"] = 15] = "LowerEquals";
+    BinaryOperator[BinaryOperator["Bigger"] = 16] = "Bigger";
+    BinaryOperator[BinaryOperator["BiggerEquals"] = 17] = "BiggerEquals";
+    BinaryOperator[BinaryOperator["NullishCoalesce"] = 18] = "NullishCoalesce";
+    BinaryOperator[BinaryOperator["Exponentiation"] = 19] = "Exponentiation";
+    BinaryOperator[BinaryOperator["In"] = 20] = "In";
 })(BinaryOperator || (BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
     if (base == null || other == null) {
@@ -1083,7 +1084,7 @@ class ReadVarExpr extends Expression {
         return new ReadVarExpr(this.name, this.type, this.sourceSpan);
     }
     set(value) {
-        return new WriteVarExpr(this.name, value, null, this.sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Assign, this, value, null, this.sourceSpan);
     }
 }
 class TypeofExpr extends Expression {
@@ -1143,85 +1144,6 @@ class WrappedNodeExpr extends Expression {
         return new WrappedNodeExpr(this.node, this.type, this.sourceSpan);
     }
 }
-class WriteVarExpr extends Expression {
-    name;
-    value;
-    constructor(name, value, type, sourceSpan) {
-        super(type || value.type, sourceSpan);
-        this.name = name;
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return e instanceof WriteVarExpr && this.name === e.name && this.value.isEquivalent(e.value);
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitWriteVarExpr(this, context);
-    }
-    clone() {
-        return new WriteVarExpr(this.name, this.value.clone(), this.type, this.sourceSpan);
-    }
-    toDeclStmt(type, modifiers) {
-        return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);
-    }
-    toConstDecl() {
-        return this.toDeclStmt(INFERRED_TYPE, exports.StmtModifier.Final);
-    }
-}
-class WriteKeyExpr extends Expression {
-    receiver;
-    index;
-    value;
-    constructor(receiver, index, value, type, sourceSpan) {
-        super(type || value.type, sourceSpan);
-        this.receiver = receiver;
-        this.index = index;
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return (e instanceof WriteKeyExpr &&
-            this.receiver.isEquivalent(e.receiver) &&
-            this.index.isEquivalent(e.index) &&
-            this.value.isEquivalent(e.value));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitWriteKeyExpr(this, context);
-    }
-    clone() {
-        return new WriteKeyExpr(this.receiver.clone(), this.index.clone(), this.value.clone(), this.type, this.sourceSpan);
-    }
-}
-class WritePropExpr extends Expression {
-    receiver;
-    name;
-    value;
-    constructor(receiver, name, value, type, sourceSpan) {
-        super(type || value.type, sourceSpan);
-        this.receiver = receiver;
-        this.name = name;
-        this.value = value;
-    }
-    isEquivalent(e) {
-        return (e instanceof WritePropExpr &&
-            this.receiver.isEquivalent(e.receiver) &&
-            this.name === e.name &&
-            this.value.isEquivalent(e.value));
-    }
-    isConstant() {
-        return false;
-    }
-    visitExpression(visitor, context) {
-        return visitor.visitWritePropExpr(this, context);
-    }
-    clone() {
-        return new WritePropExpr(this.receiver.clone(), this.name, this.value.clone(), this.type, this.sourceSpan);
-    }
-}
 class InvokeFunctionExpr extends Expression {
     fn;
     args;
@@ -1775,7 +1697,7 @@ class ReadPropExpr extends Expression {
         return visitor.visitReadPropExpr(this, context);
     }
     set(value) {
-        return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Assign, this.receiver.prop(this.name), value, null, this.sourceSpan);
     }
     clone() {
         return new ReadPropExpr(this.receiver.clone(), this.name, this.type, this.sourceSpan);
@@ -1801,7 +1723,7 @@ class ReadKeyExpr extends Expression {
         return visitor.visitReadKeyExpr(this, context);
     }
     set(value) {
-        return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Assign, this.receiver.key(this.index), value, null, this.sourceSpan);
     }
     clone() {
         return new ReadKeyExpr(this.receiver.clone(), this.index.clone(), this.type, this.sourceSpan);
@@ -2038,21 +1960,6 @@ let RecursiveAstVisitor$1 = class RecursiveAstVisitor {
     visitReadVarExpr(ast, context) {
         return this.visitExpression(ast, context);
     }
-    visitWriteVarExpr(ast, context) {
-        ast.value.visitExpression(this, context);
-        return this.visitExpression(ast, context);
-    }
-    visitWriteKeyExpr(ast, context) {
-        ast.receiver.visitExpression(this, context);
-        ast.index.visitExpression(this, context);
-        ast.value.visitExpression(this, context);
-        return this.visitExpression(ast, context);
-    }
-    visitWritePropExpr(ast, context) {
-        ast.receiver.visitExpression(this, context);
-        ast.value.visitExpression(this, context);
-        return this.visitExpression(ast, context);
-    }
     visitDynamicImportExpr(ast, context) {
         return this.visitExpression(ast, context);
     }
@@ -2382,7 +2289,7 @@ class ConstantPool {
         if ((!newValue && !fixup.shared) || (newValue && forceShared)) {
             // Replace the expression with a variable
             const name = this.freshName();
-            let definition;
+            let value;
             let usage;
             if (this.isClosureCompilerEnabled && isLongStringLiteral(literal)) {
                 // For string literals, Closure will **always** inline the string at
@@ -2398,20 +2305,20 @@ class ConstantPool {
                 // const myStr = function() { return "very very very long string"; };
                 // const usage1 = myStr();
                 // const usage2 = myStr();
-                definition = variable(name).set(new FunctionExpr([], // Params.
+                value = new FunctionExpr([], // Params.
                 [
                     // Statements.
                     new ReturnStatement(literal),
-                ]));
+                ]);
                 usage = variable(name).callFn([]);
             }
             else {
                 // Just declare and use the variable directly, without a function call
                 // indirection. This saves a few bytes and avoids an unnecessary call.
-                definition = variable(name).set(literal);
+                value = literal;
                 usage = variable(name);
             }
-            this.statements.push(definition.toDeclStmt(INFERRED_TYPE, exports.StmtModifier.Final));
+            this.statements.push(new DeclareVarStmt(name, value, INFERRED_TYPE, exports.StmtModifier.Final));
             fixup.fixup(usage);
         }
         return fixup;
@@ -2482,9 +2389,7 @@ class ConstantPool {
                 .map((e) => new FnParam(e.name, DYNAMIC_TYPE));
             const pureFunctionDeclaration = arrowFn(parameters, resultMap(resultExpressions), INFERRED_TYPE);
             const name = this.freshName();
-            this.statements.push(variable(name)
-                .set(pureFunctionDeclaration)
-                .toDeclStmt(INFERRED_TYPE, exports.StmtModifier.Final));
+            this.statements.push(new DeclareVarStmt(name, pureFunctionDeclaration, INFERRED_TYPE, exports.StmtModifier.Final));
             literalFactory = variable(name);
             this.literalFactories.set(key, literalFactory);
         }
@@ -3381,46 +3286,6 @@ class AbstractEmitterVisitor {
         ctx.println(stmt, `}`);
         return null;
     }
-    visitWriteVarExpr(expr, ctx) {
-        const lineWasEmpty = ctx.lineIsEmpty();
-        if (!lineWasEmpty) {
-            ctx.print(expr, '(');
-        }
-        ctx.print(expr, `${expr.name} = `);
-        expr.value.visitExpression(this, ctx);
-        if (!lineWasEmpty) {
-            ctx.print(expr, ')');
-        }
-        return null;
-    }
-    visitWriteKeyExpr(expr, ctx) {
-        const lineWasEmpty = ctx.lineIsEmpty();
-        if (!lineWasEmpty) {
-            ctx.print(expr, '(');
-        }
-        expr.receiver.visitExpression(this, ctx);
-        ctx.print(expr, `[`);
-        expr.index.visitExpression(this, ctx);
-        ctx.print(expr, `] = `);
-        expr.value.visitExpression(this, ctx);
-        if (!lineWasEmpty) {
-            ctx.print(expr, ')');
-        }
-        return null;
-    }
-    visitWritePropExpr(expr, ctx) {
-        const lineWasEmpty = ctx.lineIsEmpty();
-        if (!lineWasEmpty) {
-            ctx.print(expr, '(');
-        }
-        expr.receiver.visitExpression(this, ctx);
-        ctx.print(expr, `.${expr.name} = `);
-        expr.value.visitExpression(this, ctx);
-        if (!lineWasEmpty) {
-            ctx.print(expr, ')');
-        }
-        return null;
-    }
     visitInvokeFunctionExpr(expr, ctx) {
         const shouldParenthesize = expr.fn instanceof ArrowFunctionExpr;
         if (shouldParenthesize) {
@@ -3542,6 +3407,9 @@ class AbstractEmitterVisitor {
     visitBinaryOperatorExpr(ast, ctx) {
         let opStr;
         switch (ast.operator) {
+            case BinaryOperator.Assign:
+                opStr = '=';
+                break;
             case BinaryOperator.Equals:
                 opStr = '==';
                 break;
@@ -3821,7 +3689,7 @@ function compileFactoryFunction(meta) {
     let retExpr = null;
     function makeConditionalFactory(nonCtorExpr) {
         const r = variable('__ngConditionalFactory__');
-        body.push(r.set(NULL_EXPR).toDeclStmt());
+        body.push(new DeclareVarStmt(r.name, NULL_EXPR, INFERRED_TYPE));
         const ctorStmt = ctorExpr !== null
             ? r.set(ctorExpr).toStmt()
             : importExpr(Identifiers.invalidFactory).callFn([]).toStmt();
@@ -4081,20 +3949,6 @@ class PropertyRead extends ASTWithName {
         return visitor.visitPropertyRead(this, context);
     }
 }
-class PropertyWrite extends ASTWithName {
-    receiver;
-    name;
-    value;
-    constructor(span, sourceSpan, nameSpan, receiver, name, value) {
-        super(span, sourceSpan, nameSpan);
-        this.receiver = receiver;
-        this.name = name;
-        this.value = value;
-    }
-    visit(visitor, context = null) {
-        return visitor.visitPropertyWrite(this, context);
-    }
-}
 class SafePropertyRead extends ASTWithName {
     receiver;
     name;
@@ -4131,29 +3985,31 @@ class SafeKeyedRead extends AST {
         return visitor.visitSafeKeyedRead(this, context);
     }
 }
-class KeyedWrite extends AST {
-    receiver;
-    key;
-    value;
-    constructor(span, sourceSpan, receiver, key, value) {
-        super(span, sourceSpan);
-        this.receiver = receiver;
-        this.key = key;
-        this.value = value;
-    }
-    visit(visitor, context = null) {
-        return visitor.visitKeyedWrite(this, context);
-    }
-}
+/** Possible types for a pipe. */
+exports.BindingPipeType = void 0;
+(function (BindingPipeType) {
+    /**
+     * Pipe is being referenced by its name, for example:
+     * `@Pipe({name: 'foo'}) class FooPipe` and `{{123 | foo}}`.
+     */
+    BindingPipeType[BindingPipeType["ReferencedByName"] = 0] = "ReferencedByName";
+    /**
+     * Pipe is being referenced by its class name, for example:
+     * `@Pipe() class FooPipe` and `{{123 | FooPipe}}`.
+     */
+    BindingPipeType[BindingPipeType["ReferencedDirectly"] = 1] = "ReferencedDirectly";
+})(exports.BindingPipeType || (exports.BindingPipeType = {}));
 class BindingPipe extends ASTWithName {
     exp;
     name;
     args;
-    constructor(span, sourceSpan, exp, name, args, nameSpan) {
+    type;
+    constructor(span, sourceSpan, exp, name, args, type, nameSpan) {
         super(span, sourceSpan, nameSpan);
         this.exp = exp;
         this.name = name;
         this.args = args;
+        this.type = type;
     }
     visit(visitor, context = null) {
         return visitor.visitPipe(this, context);
@@ -4474,11 +4330,6 @@ class RecursiveAstVisitor {
         this.visit(ast.receiver, context);
         this.visit(ast.key, context);
     }
-    visitKeyedWrite(ast, context) {
-        this.visit(ast.receiver, context);
-        this.visit(ast.key, context);
-        this.visit(ast.value, context);
-    }
     visitLiteralArray(ast, context) {
         this.visitAll(ast.expressions, context);
     }
@@ -4501,10 +4352,6 @@ class RecursiveAstVisitor {
     visitPropertyRead(ast, context) {
         this.visit(ast.receiver, context);
     }
-    visitPropertyWrite(ast, context) {
-        this.visit(ast.receiver, context);
-        this.visit(ast.value, context);
-    }
     visitSafePropertyRead(ast, context) {
         this.visit(ast.receiver, context);
     }
@@ -4830,11 +4677,12 @@ let Element$1 = class Element {
     directives;
     children;
     references;
+    isSelfClosing;
     sourceSpan;
     startSourceSpan;
     endSourceSpan;
     i18n;
-    constructor(name, attributes, inputs, outputs, directives, children, references, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
+    constructor(name, attributes, inputs, outputs, directives, children, references, isSelfClosing, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
         this.name = name;
         this.attributes = attributes;
         this.inputs = inputs;
@@ -4842,6 +4690,7 @@ let Element$1 = class Element {
         this.directives = directives;
         this.children = children;
         this.references = references;
+        this.isSelfClosing = isSelfClosing;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
@@ -5148,11 +4997,12 @@ let Component$1 = class Component {
     directives;
     children;
     references;
+    isSelfClosing;
     sourceSpan;
     startSourceSpan;
     endSourceSpan;
     i18n;
-    constructor(componentName, tagName, fullName, attributes, inputs, outputs, directives, children, references, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
+    constructor(componentName, tagName, fullName, attributes, inputs, outputs, directives, children, references, isSelfClosing, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
         this.componentName = componentName;
         this.tagName = tagName;
         this.fullName = fullName;
@@ -5162,6 +5012,7 @@ let Component$1 = class Component {
         this.directives = directives;
         this.children = children;
         this.references = references;
+        this.isSelfClosing = isSelfClosing;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
@@ -5206,6 +5057,7 @@ class Template {
     children;
     references;
     variables;
+    isSelfClosing;
     sourceSpan;
     startSourceSpan;
     endSourceSpan;
@@ -5215,7 +5067,7 @@ class Template {
     // `null` is a special case for when there is a structural directive on an `ng-template` so
     // the renderer can differentiate between the synthetic template and the one written in the
     // file.
-    tagName, attributes, inputs, outputs, directives, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
+    tagName, attributes, inputs, outputs, directives, templateAttrs, children, references, variables, isSelfClosing, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
         this.tagName = tagName;
         this.attributes = attributes;
         this.inputs = inputs;
@@ -5225,6 +5077,7 @@ class Template {
         this.children = children;
         this.references = references;
         this.variables = variables;
+        this.isSelfClosing = isSelfClosing;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
@@ -5238,15 +5091,17 @@ class Content {
     selector;
     attributes;
     children;
+    isSelfClosing;
     sourceSpan;
     startSourceSpan;
     endSourceSpan;
     i18n;
     name = 'ng-content';
-    constructor(selector, attributes, children, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
+    constructor(selector, attributes, children, isSelfClosing, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
         this.selector = selector;
         this.attributes = attributes;
         this.children = children;
+        this.isSelfClosing = isSelfClosing;
         this.sourceSpan = sourceSpan;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
@@ -5412,7 +5267,7 @@ function visitAll$1(visitor, nodes) {
     const result = [];
     if (visitor.visit) {
         for (const node of nodes) {
-            visitor.visit(node) || node.visit(visitor);
+            visitor.visit(node);
         }
     }
     else {
@@ -7308,7 +7163,11 @@ function tupleOfTypes(types) {
 function compilePipeFromMetadata(metadata) {
     const definitionMapValues = [];
     // e.g. `name: 'myPipe'`
-    definitionMapValues.push({ key: 'name', value: literal$1(metadata.pipeName), quoted: false });
+    definitionMapValues.push({
+        key: 'name',
+        value: literal$1(metadata.pipeName ?? metadata.name),
+        quoted: false,
+    });
     // e.g. `type: MyPipe`
     definitionMapValues.push({ key: 'type', value: metadata.type.value, quoted: false });
     // e.g. `pure: true`
@@ -10324,15 +10183,6 @@ function transformExpressionsInExpression(expr, transform, flags) {
         expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
         expr.index = transformExpressionsInExpression(expr.index, transform, flags);
     }
-    else if (expr instanceof WritePropExpr) {
-        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
-        expr.value = transformExpressionsInExpression(expr.value, transform, flags);
-    }
-    else if (expr instanceof WriteKeyExpr) {
-        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
-        expr.index = transformExpressionsInExpression(expr.index, transform, flags);
-        expr.value = transformExpressionsInExpression(expr.value, transform, flags);
-    }
     else if (expr instanceof InvokeFunctionExpr) {
         expr.fn = transformExpressionsInExpression(expr.fn, transform, flags);
         for (let i = 0; i < expr.args.length; i++) {
@@ -10362,9 +10212,6 @@ function transformExpressionsInExpression(expr, transform, flags) {
     else if (expr instanceof VoidExpr) {
         expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
     }
-    else if (expr instanceof WriteVarExpr) {
-        expr.value = transformExpressionsInExpression(expr.value, transform, flags);
-    }
     else if (expr instanceof LocalizedString) {
         for (let i = 0; i < expr.expressions.length; i++) {
             expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform, flags);
@@ -11947,6 +11794,7 @@ const BINARY_OPERATORS$3 = new Map([
     ['|', BinaryOperator.BitwiseOr],
     ['&', BinaryOperator.BitwiseAnd],
     ['/', BinaryOperator.Divide],
+    ['=', BinaryOperator.Assign],
     ['==', BinaryOperator.Equals],
     ['===', BinaryOperator.Identical],
     ['<', BinaryOperator.Lower],
@@ -13430,14 +13278,16 @@ class Element extends NodeWithI18n {
     attrs;
     directives;
     children;
+    isSelfClosing;
     startSourceSpan;
     endSourceSpan;
-    constructor(name, attrs, directives, children, sourceSpan, startSourceSpan, endSourceSpan = null, i18n) {
+    constructor(name, attrs, directives, children, isSelfClosing, sourceSpan, startSourceSpan, endSourceSpan = null, i18n) {
         super(sourceSpan, i18n);
         this.name = name;
         this.attrs = attrs;
         this.directives = directives;
         this.children = children;
+        this.isSelfClosing = isSelfClosing;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
     }
@@ -13483,9 +13333,10 @@ class Component extends NodeWithI18n {
     attrs;
     directives;
     children;
+    isSelfClosing;
     startSourceSpan;
     endSourceSpan;
-    constructor(componentName, tagName, fullName, attrs, directives, children, sourceSpan, startSourceSpan, endSourceSpan = null, i18n) {
+    constructor(componentName, tagName, fullName, attrs, directives, children, isSelfClosing, sourceSpan, startSourceSpan, endSourceSpan = null, i18n) {
         super(sourceSpan, i18n);
         this.componentName = componentName;
         this.tagName = tagName;
@@ -13493,6 +13344,7 @@ class Component extends NodeWithI18n {
         this.attrs = attrs;
         this.directives = directives;
         this.children = children;
+        this.isSelfClosing = isSelfClosing;
         this.startSourceSpan = startSourceSpan;
         this.endSourceSpan = endSourceSpan;
     }
@@ -17404,7 +17256,7 @@ class _TreeBuilder {
         const span = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
         // Create a separate `startSpan` because `span` will be modified when there is an `end` span.
         const startSpan = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
-        const el = new Element(fullName, attrs, directives, [], span, startSpan, undefined);
+        const el = new Element(fullName, attrs, directives, [], selfClosing, span, startSpan, undefined);
         const parent = this._getContainer();
         const isClosedByChild = parent !== null && !!this._getTagDefinition(parent)?.isClosedByChild(el.name);
         this._pushContainer(el, isClosedByChild);
@@ -17433,7 +17285,7 @@ class _TreeBuilder {
         const end = this._peek.sourceSpan.fullStart;
         const span = new ParseSourceSpan(startToken.sourceSpan.start, end, startToken.sourceSpan.fullStart);
         const startSpan = new ParseSourceSpan(startToken.sourceSpan.start, end, startToken.sourceSpan.fullStart);
-        const node = new Component(componentName, tagName, fullName, attrs, directives, [], span, startSpan, undefined);
+        const node = new Component(componentName, tagName, fullName, attrs, directives, [], selfClosing, span, startSpan, undefined);
         const parent = this._getContainer();
         const isClosedByChild = parent !== null &&
             node.tagName !== null &&
@@ -17847,11 +17699,11 @@ class WhitespaceVisitor {
         if (SKIP_WS_TRIM_TAGS.has(element.name) || hasPreserveWhitespacesAttr(element.attrs)) {
             // don't descent into elements where we need to preserve whitespaces
             // but still visit all attributes to eliminate one used as a market to preserve WS
-            const newElement = new Element(element.name, visitAllWithSiblings(this, element.attrs), visitAllWithSiblings(this, element.directives), element.children, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
+            const newElement = new Element(element.name, visitAllWithSiblings(this, element.attrs), visitAllWithSiblings(this, element.directives), element.children, element.isSelfClosing, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
             this.originalNodeMap?.set(newElement, element);
             return newElement;
         }
-        const newElement = new Element(element.name, element.attrs, element.directives, visitAllWithSiblings(this, element.children), element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
+        const newElement = new Element(element.name, element.attrs, element.directives, visitAllWithSiblings(this, element.children), element.isSelfClosing, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
         this.originalNodeMap?.set(newElement, element);
         return newElement;
     }
@@ -17930,11 +17782,11 @@ class WhitespaceVisitor {
             hasPreserveWhitespacesAttr(node.attrs)) {
             // don't descent into elements where we need to preserve whitespaces
             // but still visit all attributes to eliminate one used as a market to preserve WS
-            const newElement = new Component(node.componentName, node.tagName, node.fullName, visitAllWithSiblings(this, node.attrs), visitAllWithSiblings(this, node.directives), node.children, node.sourceSpan, node.startSourceSpan, node.endSourceSpan, node.i18n);
+            const newElement = new Component(node.componentName, node.tagName, node.fullName, visitAllWithSiblings(this, node.attrs), visitAllWithSiblings(this, node.directives), node.children, node.isSelfClosing, node.sourceSpan, node.startSourceSpan, node.endSourceSpan, node.i18n);
             this.originalNodeMap?.set(newElement, node);
             return newElement;
         }
-        const newElement = new Component(node.componentName, node.tagName, node.fullName, node.attrs, node.directives, visitAllWithSiblings(this, node.children), node.sourceSpan, node.startSourceSpan, node.endSourceSpan, node.i18n);
+        const newElement = new Component(node.componentName, node.tagName, node.fullName, node.attrs, node.directives, visitAllWithSiblings(this, node.children), node.isSelfClosing, node.sourceSpan, node.startSourceSpan, node.endSourceSpan, node.i18n);
         this.originalNodeMap?.set(newElement, node);
         return newElement;
     }
@@ -18534,20 +18386,23 @@ class TemplateBindingParseResult {
 }
 class Parser {
     _lexer;
-    errors = [];
-    constructor(_lexer) {
+    _supportsDirectPipeReferences;
+    constructor(_lexer, _supportsDirectPipeReferences = false) {
         this._lexer = _lexer;
+        this._supportsDirectPipeReferences = _supportsDirectPipeReferences;
     }
     parseAction(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-        this._checkNoInterpolation(input, location, interpolationConfig);
+        const errors = [];
+        this._checkNoInterpolation(errors, input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        const ast = new _ParseAST(input, location, absoluteOffset, tokens, 1 /* ParseFlags.Action */, this.errors, 0).parseChain();
-        return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);
+        const ast = new _ParseAST(input, location, absoluteOffset, tokens, 1 /* ParseFlags.Action */, errors, 0, this._supportsDirectPipeReferences).parseChain();
+        return new ASTWithSource(ast, input, location, absoluteOffset, errors);
     }
     parseBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-        const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig);
-        return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);
+        const errors = [];
+        const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig, errors);
+        return new ASTWithSource(ast, input, location, absoluteOffset, errors);
     }
     checkSimpleExpression(ast) {
         const checker = new SimpleExpressionChecker();
@@ -18556,21 +18411,19 @@ class Parser {
     }
     // Host bindings parsed here
     parseSimpleBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-        const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig);
-        const errors = this.checkSimpleExpression(ast);
-        if (errors.length > 0) {
-            this._reportError(`Host binding expression cannot contain ${errors.join(' ')}`, input, location);
+        const errors = [];
+        const ast = this._parseBindingAst(input, location, 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));
         }
-        return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);
-    }
-    _reportError(message, input, errLocation, ctxLocation) {
-        this.errors.push(new ParserError(message, input, errLocation, ctxLocation));
+        return new ASTWithSource(ast, input, location, absoluteOffset, errors);
     }
-    _parseBindingAst(input, location, absoluteOffset, interpolationConfig) {
-        this._checkNoInterpolation(input, location, interpolationConfig);
+    _parseBindingAst(input, location, absoluteOffset, interpolationConfig, errors) {
+        this._checkNoInterpolation(errors, input, location, interpolationConfig);
         const sourceToLex = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
-        return new _ParseAST(input, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, this.errors, 0).parseChain();
+        return new _ParseAST(input, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, 0, this._supportsDirectPipeReferences).parseChain();
     }
     /**
      * Parse microsyntax template expression and return a list of bindings or
@@ -18600,14 +18453,16 @@ class Parser {
      */
     parseTemplateBindings(templateKey, templateValue, templateUrl, absoluteKeyOffset, absoluteValueOffset) {
         const tokens = this._lexer.tokenize(templateValue);
-        const parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, 0 /* ParseFlags.None */, this.errors, 0 /* relative offset */);
+        const errors = [];
+        const parser = new _ParseAST(templateValue, templateUrl, 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) {
-        const { strings, expressions, offsets } = this.splitInterpolation(input, location, interpolatedTokens, interpolationConfig);
+        const errors = [];
+        const { strings, expressions, offsets } = this.splitInterpolation(input, location, errors, interpolatedTokens, interpolationConfig);
         if (expressions.length === 0)
             return null;
         const expressionNodes = [];
@@ -18615,10 +18470,10 @@ 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 */, this.errors, offsets[i]).parseChain();
+            const ast = new _ParseAST(input, location, 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);
+        return this.createInterpolationAst(strings.map((s) => s.text), expressionNodes, input, location, absoluteOffset, errors);
     }
     /**
      * Similar to `parseInterpolation`, but treats the provided string as a single expression
@@ -18628,14 +18483,15 @@ class Parser {
     parseInterpolationExpression(expression, location, absoluteOffset) {
         const sourceToLex = this._stripComments(expression);
         const tokens = this._lexer.tokenize(sourceToLex);
-        const ast = new _ParseAST(expression, location, absoluteOffset, tokens, 0 /* ParseFlags.None */, this.errors, 0).parseChain();
+        const errors = [];
+        const ast = new _ParseAST(expression, location, 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);
+        return this.createInterpolationAst(strings, [ast], expression, location, absoluteOffset, errors);
     }
-    createInterpolationAst(strings, expressions, input, location, absoluteOffset) {
+    createInterpolationAst(strings, expressions, input, location, absoluteOffset, errors) {
         const span = new ParseSpan(0, input.length);
         const interpolation = new Interpolation$1(span, span.toAbsolute(absoluteOffset), strings, expressions);
-        return new ASTWithSource(interpolation, input, location, absoluteOffset, this.errors);
+        return new ASTWithSource(interpolation, input, location, absoluteOffset, errors);
     }
     /**
      * Splits a string of text into "raw" text segments and expressions present in interpolations in
@@ -18644,7 +18500,7 @@ class Parser {
      * `SplitInterpolation` with splits that look like
      *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
      */
-    splitInterpolation(input, location, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    splitInterpolation(input, location, errors, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         const strings = [];
         const expressions = [];
         const offsets = [];
@@ -18682,7 +18538,7 @@ class Parser {
                 const fullEnd = exprEnd + interpEnd.length;
                 const text = input.substring(exprStart, exprEnd);
                 if (text.trim().length === 0) {
-                    this._reportError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, location);
+                    errors.push(new ParserError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, location));
                 }
                 expressions.push({ text, start: fullStart, end: fullEnd });
                 const startInOriginalTemplate = inputToTemplateIndexMap?.get(fullStart) ?? fullStart;
@@ -18707,7 +18563,7 @@ class Parser {
     }
     wrapLiteralPrimitive(input, location, absoluteOffset) {
         const span = new ParseSpan(0, input == null ? 0 : input.length);
-        return new ASTWithSource(new LiteralPrimitive(span, span.toAbsolute(absoluteOffset), input), input, location, absoluteOffset, this.errors);
+        return new ASTWithSource(new LiteralPrimitive(span, span.toAbsolute(absoluteOffset), input), input, location, absoluteOffset, []);
     }
     _stripComments(input) {
         const i = this._commentStart(input);
@@ -18729,7 +18585,7 @@ class Parser {
         }
         return null;
     }
-    _checkNoInterpolation(input, location, { start, end }) {
+    _checkNoInterpolation(errors, input, location, { start, end }) {
         let startIndex = -1;
         let endIndex = -1;
         for (const charIndex of this._forEachUnquotedChar(input, 0)) {
@@ -18746,7 +18602,7 @@ class Parser {
             }
         }
         if (startIndex > -1 && endIndex > -1) {
-            this._reportError(`Got interpolation (${start}${end}) where expression was expected`, input, `at column ${startIndex} in`, location);
+            errors.push(new ParserError(`Got interpolation (${start}${end}) where expression was expected`, input, `at column ${startIndex} in`, location));
         }
     }
     /**
@@ -18811,6 +18667,7 @@ class _ParseAST {
     parseFlags;
     errors;
     offset;
+    supportsDirectPipeReferences;
     rparensExpected = 0;
     rbracketsExpected = 0;
     rbracesExpected = 0;
@@ -18821,7 +18678,7 @@ 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) {
+    constructor(input, location, absoluteOffset, tokens, parseFlags, errors, offset, supportsDirectPipeReferences) {
         this.input = input;
         this.location = location;
         this.absoluteOffset = absoluteOffset;
@@ -18829,6 +18686,7 @@ class _ParseAST {
         this.parseFlags = parseFlags;
         this.errors = errors;
         this.offset = offset;
+        this.supportsDirectPipeReferences = supportsDirectPipeReferences;
     }
     peek(offset) {
         const i = this.index + offset;
@@ -19057,7 +18915,18 @@ class _ParseAST {
                     // If there are additional expressions beyond the name, then the artificial end for the
                     // name is no longer relevant.
                 }
-                result = new BindingPipe(this.span(start), this.sourceSpan(start, fullSpanEnd), result, nameId, args, nameSpan);
+                let type;
+                if (this.supportsDirectPipeReferences) {
+                    const charCode = nameId.charCodeAt(0);
+                    type =
+                        charCode === $_ || (charCode >= $A && charCode <= $Z)
+                            ? exports.BindingPipeType.ReferencedDirectly
+                            : exports.BindingPipeType.ReferencedByName;
+                }
+                else {
+                    type = exports.BindingPipeType.ReferencedByName;
+                }
+                result = new BindingPipe(this.span(start), this.sourceSpan(start, fullSpanEnd), result, nameId, args, type, nameSpan);
             } while (this.consumeOptionalOperator('|'));
         }
         return result;
@@ -19421,14 +19290,13 @@ class _ParseAST {
             return id;
         });
         const nameSpan = this.sourceSpan(nameStart);
-        let receiver;
         if (isSafe) {
             if (this.consumeOptionalOperator('=')) {
                 this.error("The '?.' operator cannot be used in the assignment");
-                receiver = new EmptyExpr$1(this.span(start), this.sourceSpan(start));
+                return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
             }
             else {
-                receiver = new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
+                return new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
             }
         }
         else {
@@ -19437,14 +19305,14 @@ class _ParseAST {
                     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();
-                receiver = new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id, value);
+                return new Binary(this.span(start), this.sourceSpan(start), '=', receiver, value);
             }
             else {
-                receiver = new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
+                return new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
             }
         }
-        return receiver;
     }
     parseCall(receiver, start, isSafe) {
         const argumentStart = this.inputIndex;
@@ -19559,8 +19427,9 @@ class _ParseAST {
                     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 KeyedWrite(this.span(start), this.sourceSpan(start), receiver, key, value);
+                    return new Binary(this.span(start), this.sourceSpan(start), '=', binaryReceiver, value);
                 }
             }
             else {
@@ -19863,9 +19732,6 @@ class SerializeExpressionVisitor {
     visitKeyedRead(ast, context) {
         return `${ast.receiver.visit(this, context)}[${ast.key.visit(this, context)}]`;
     }
-    visitKeyedWrite(ast, context) {
-        return `${ast.receiver.visit(this, context)}[${ast.key.visit(this, context)}] = ${ast.value.visit(this, context)}`;
-    }
     visitLiteralArray(ast, context) {
         return `[${ast.expressions.map((e) => e.visit(this, context)).join(', ')}]`;
     }
@@ -19906,14 +19772,6 @@ class SerializeExpressionVisitor {
             return `${ast.receiver.visit(this, context)}.${ast.name}`;
         }
     }
-    visitPropertyWrite(ast, context) {
-        if (ast.receiver instanceof ImplicitReceiver) {
-            return `${ast.name} = ${ast.value.visit(this, context)}`;
-        }
-        else {
-            return `${ast.receiver.visit(this, context)}.${ast.name} = ${ast.value.visit(this, context)}`;
-        }
-    }
     visitSafePropertyRead(ast, context) {
         return `${ast.receiver.visit(this, context)}?.${ast.name}`;
     }
@@ -21530,7 +21388,7 @@ function createGoogleGetMsgStatements(variable$1, message, closureVar, placehold
     //  */
     // const MSG_... = goog.getMsg(..);
     // I18N_X = MSG_...;
-    const googGetMsgStmt = closureVar.set(variable(GOOG_GET_MSG).callFn(args)).toConstDecl();
+    const googGetMsgStmt = new DeclareVarStmt(closureVar.name, variable(GOOG_GET_MSG).callFn(args), INFERRED_TYPE, exports.StmtModifier.Final);
     googGetMsgStmt.addLeadingComment(i18nMetaToJSDoc(message));
     const i18nAssignmentStmt = new ExpressionStatement(variable$1.set(closureVar));
     return [googGetMsgStmt, i18nAssignmentStmt];
@@ -26578,17 +26436,6 @@ function convertAst(ast, job, baseSourceSpan) {
             return new ReadPropExpr(convertAst(ast.receiver, job, baseSourceSpan), ast.name, null, convertSourceSpan(ast.span, baseSourceSpan));
         }
     }
-    else if (ast instanceof PropertyWrite) {
-        if (ast.receiver instanceof ImplicitReceiver) {
-            return new WritePropExpr(
-            // TODO: Is it correct to always use the root context in place of the implicit receiver?
-            new ContextExpr(job.root.xref), ast.name, convertAst(ast.value, job, baseSourceSpan), null, convertSourceSpan(ast.span, baseSourceSpan));
-        }
-        return new WritePropExpr(convertAst(ast.receiver, job, baseSourceSpan), ast.name, convertAst(ast.value, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
-    }
-    else if (ast instanceof KeyedWrite) {
-        return new WriteKeyExpr(convertAst(ast.receiver, job, baseSourceSpan), convertAst(ast.key, job, baseSourceSpan), convertAst(ast.value, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
-    }
     else if (ast instanceof Call) {
         if (ast.receiver instanceof ImplicitReceiver) {
             throw new Error(`Unexpected ImplicitReceiver`);
@@ -28865,7 +28712,7 @@ class HtmlAstToIvyAst {
         if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {
             const selector = preparsedElement.selectAttr;
             const attrs = element.attrs.map((attr) => this.visitAttribute(attr));
-            parsedElement = new Content(selector, attrs, children, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
+            parsedElement = new Content(selector, attrs, children, element.isSelfClosing, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
             this.ngContentSelectors.push(selector);
         }
         else if (isTemplateElement) {
@@ -28873,11 +28720,11 @@ class HtmlAstToIvyAst {
             const attrs = this.categorizePropertyAttributes(element.name, parsedProperties, i18nAttrsMeta);
             parsedElement = new Template(element.name, attributes, attrs.bound, boundEvents, directives, [
             /* no template attributes */
-            ], children, references, variables, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
+            ], children, references, variables, element.isSelfClosing, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
         }
         else {
             const attrs = this.categorizePropertyAttributes(element.name, parsedProperties, i18nAttrsMeta);
-            parsedElement = new Element$1(element.name, attributes, attrs.bound, boundEvents, directives, children, references, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
+            parsedElement = new Element$1(element.name, attributes, attrs.bound, boundEvents, directives, children, references, element.isSelfClosing, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n);
         }
         if (elementHasInlineTemplate) {
             // If this node is an inline-template (e.g. has *ngFor) then we need to create a template
@@ -28972,7 +28819,7 @@ class HtmlAstToIvyAst {
             children = visitAll(this, component.children, component.children);
         }
         const attrs = this.categorizePropertyAttributes(component.tagName, parsedProperties, i18nAttrsMeta);
-        let node = new Component$1(component.componentName, component.tagName, component.fullName, attributes, attrs.bound, boundEvents, directives, children, references, component.sourceSpan, component.startSourceSpan, component.endSourceSpan, component.i18n);
+        let node = new Component$1(component.componentName, component.tagName, component.fullName, attributes, attrs.bound, boundEvents, directives, children, references, component.isSelfClosing, component.sourceSpan, component.startSourceSpan, component.endSourceSpan, component.i18n);
         if (elementHasInlineTemplate) {
             node = this.wrapInTemplate(node, templateParsedProperties, templateVariables, i18nAttrsMeta, false, isI18nRootElement);
         }
@@ -29312,7 +29159,7 @@ class HtmlAstToIvyAst {
         // Do not copy over the directives.
         ], templateAttrs, [node], [
         // Do not copy over the references.
-        ], templateVariables, node.sourceSpan, node.startSourceSpan, node.endSourceSpan, i18n);
+        ], templateVariables, false, node.sourceSpan, node.startSourceSpan, node.endSourceSpan, i18n);
     }
     _visitTextWithInterpolation(value, sourceSpan, interpolatedTokens, i18n) {
         const valueNoNgsp = replaceNgsp(value);
@@ -29383,7 +29230,7 @@ class NonBindableVisitor {
         /* inputs */ [], 
         /* outputs */ [], 
         /* directives */ [], children, 
-        /* references */ [], ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+        /* references */ [], ast.isSelfClosing, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
     }
     visitComment(comment) {
         return null;
@@ -29424,7 +29271,7 @@ class NonBindableVisitor {
         /* inputs */ [], 
         /* outputs */ [], 
         /* directives */ [], children, 
-        /* references */ [], ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+        /* references */ [], ast.isSelfClosing, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
     }
     visitDirective(directive, context) {
         return null;
@@ -29456,7 +29303,8 @@ const LEADING_TRIVIA_CHARS = [' ', '\n', '\r', '\t'];
  */
 function parseTemplate(template, templateUrl, options = {}) {
     const { interpolationConfig, preserveWhitespaces, enableI18nLegacyMessageIdFormat } = options;
-    const bindingParser = makeBindingParser(interpolationConfig);
+    const selectorlessEnabled = options.enableSelectorless ?? false;
+    const bindingParser = makeBindingParser(interpolationConfig, selectorlessEnabled);
     const htmlParser = new HtmlParser();
     const parseResult = htmlParser.parse(template, templateUrl, {
         leadingTriviaChars: LEADING_TRIVIA_CHARS,
@@ -29464,7 +29312,7 @@ function parseTemplate(template, templateUrl, options = {}) {
         tokenizeExpansionForms: true,
         tokenizeBlocks: options.enableBlockSyntax ?? true,
         tokenizeLet: options.enableLetSyntax ?? true,
-        selectorlessEnabled: options.enableSelectorless ?? false,
+        selectorlessEnabled,
     });
     if (!options.alwaysAttemptHtmlToR3AstConversion &&
         parseResult.errors &&
@@ -29563,8 +29411,8 @@ const elementRegistry = new DomElementSchemaRegistry();
 /**
  * Construct a `BindingParser` with a default configuration.
  */
-function makeBindingParser(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-    return new BindingParser(new Parser(new Lexer()), interpolationConfig, elementRegistry, []);
+function makeBindingParser(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG, selectorlessEnabled = false) {
+    return new BindingParser(new Parser(new Lexer(), selectorlessEnabled), interpolationConfig, elementRegistry, []);
 }
 
 const COMPONENT_VARIABLE = '%COMP%';
@@ -30074,6 +29922,132 @@ function compileDeferResolverFunction(meta) {
     return arrowFn([], literalArr(depExpressions));
 }
 
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Visitor that traverses all template and expression AST nodes in a template.
+ * Useful for cases where every single node needs to be visited.
+ */
+class CombinedRecursiveAstVisitor extends RecursiveAstVisitor {
+    visit(node) {
+        if (node instanceof ASTWithSource) {
+            this.visit(node.ast);
+        }
+        else {
+            node.visit(this);
+        }
+    }
+    visitElement(element) {
+        this.visitAllTemplateNodes(element.attributes);
+        this.visitAllTemplateNodes(element.inputs);
+        this.visitAllTemplateNodes(element.outputs);
+        this.visitAllTemplateNodes(element.directives);
+        this.visitAllTemplateNodes(element.references);
+        this.visitAllTemplateNodes(element.children);
+    }
+    visitTemplate(template) {
+        this.visitAllTemplateNodes(template.attributes);
+        this.visitAllTemplateNodes(template.inputs);
+        this.visitAllTemplateNodes(template.outputs);
+        this.visitAllTemplateNodes(template.directives);
+        this.visitAllTemplateNodes(template.templateAttrs);
+        this.visitAllTemplateNodes(template.variables);
+        this.visitAllTemplateNodes(template.references);
+        this.visitAllTemplateNodes(template.children);
+    }
+    visitContent(content) {
+        this.visitAllTemplateNodes(content.children);
+    }
+    visitBoundAttribute(attribute) {
+        this.visit(attribute.value);
+    }
+    visitBoundEvent(attribute) {
+        this.visit(attribute.handler);
+    }
+    visitBoundText(text) {
+        this.visit(text.value);
+    }
+    visitIcu(icu) {
+        Object.keys(icu.vars).forEach((key) => this.visit(icu.vars[key]));
+        Object.keys(icu.placeholders).forEach((key) => this.visit(icu.placeholders[key]));
+    }
+    visitDeferredBlock(deferred) {
+        deferred.visitAll(this);
+    }
+    visitDeferredTrigger(trigger) {
+        if (trigger instanceof BoundDeferredTrigger) {
+            this.visit(trigger.value);
+        }
+    }
+    visitDeferredBlockPlaceholder(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitDeferredBlockError(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitDeferredBlockLoading(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitSwitchBlock(block) {
+        this.visit(block.expression);
+        this.visitAllTemplateNodes(block.cases);
+    }
+    visitSwitchBlockCase(block) {
+        block.expression && this.visit(block.expression);
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitForLoopBlock(block) {
+        block.item.visit(this);
+        this.visitAllTemplateNodes(block.contextVariables);
+        this.visit(block.expression);
+        this.visitAllTemplateNodes(block.children);
+        block.empty?.visit(this);
+    }
+    visitForLoopBlockEmpty(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitIfBlock(block) {
+        this.visitAllTemplateNodes(block.branches);
+    }
+    visitIfBlockBranch(block) {
+        block.expression && this.visit(block.expression);
+        block.expressionAlias?.visit(this);
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitLetDeclaration(decl) {
+        this.visit(decl.value);
+    }
+    visitComponent(component) {
+        this.visitAllTemplateNodes(component.attributes);
+        this.visitAllTemplateNodes(component.inputs);
+        this.visitAllTemplateNodes(component.outputs);
+        this.visitAllTemplateNodes(component.directives);
+        this.visitAllTemplateNodes(component.references);
+        this.visitAllTemplateNodes(component.children);
+    }
+    visitDirective(directive) {
+        this.visitAllTemplateNodes(directive.attributes);
+        this.visitAllTemplateNodes(directive.inputs);
+        this.visitAllTemplateNodes(directive.outputs);
+        this.visitAllTemplateNodes(directive.references);
+    }
+    visitVariable(variable) { }
+    visitReference(reference) { }
+    visitTextAttribute(attribute) { }
+    visitText(text) { }
+    visitUnknownBlock(block) { }
+    visitAllTemplateNodes(nodes) {
+        for (const node of nodes) {
+            this.visit(node);
+        }
+    }
+}
+
 /**
  * Processes `Target`s with a given set of directives and performs a binding operation, which
  * returns an object similar to TypeScript's `ts.TypeChecker` that contains knowledge about the
@@ -30115,9 +30089,7 @@ class R3TargetBinder {
             //   - bindings: Map of inputs, outputs, and attributes to the directive/element that claims
             //     them. TODO(alxhub): handle multiple directives claiming an input/output/etc.
             //   - references: Map of #references to their targets.
-            if (this.directiveMatcher !== null) {
-                DirectiveBinder.apply(target.template, this.directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references);
-            }
+            DirectiveBinder.apply(target.template, this.directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references);
             // Finally, run the TemplateBinder to bind references, variables, and other entities within the
             // template. This extracts all the metadata that doesn't depend on directive matching.
             TemplateBinder.applyWithScope(target.template, scope, expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks);
@@ -30451,6 +30423,13 @@ class DirectiveBinder {
             this.directiveMatcher.match(cssSelector, (_, results) => directives.push(...results));
             this.trackSelectorBasedBindingsAndDirectives(node, directives);
         }
+        else {
+            node.references.forEach((ref) => {
+                if (ref.value.trim() === '') {
+                    this.references.set(ref, node);
+                }
+            });
+        }
         node.directives.forEach((directive) => directive.visit(this));
         node.children.forEach((child) => child.visit(this));
     }
@@ -30553,7 +30532,7 @@ class DirectiveBinder {
  * Expressions are visited by the superclass `RecursiveAstVisitor`, with custom logic provided
  * by overridden methods from that visitor.
  */
-class TemplateBinder extends RecursiveAstVisitor {
+class TemplateBinder extends CombinedRecursiveAstVisitor {
     bindings;
     symbols;
     usedPipes;
@@ -30563,7 +30542,7 @@ class TemplateBinder extends RecursiveAstVisitor {
     scope;
     rootNode;
     level;
-    visitNode;
+    visitNode = (node) => node.visit(this);
     constructor(bindings, symbols, usedPipes, eagerPipes, deferBlocks, nestingLevel, scope, rootNode, level) {
         super();
         this.bindings = bindings;
@@ -30575,19 +30554,6 @@ class TemplateBinder extends RecursiveAstVisitor {
         this.scope = scope;
         this.rootNode = rootNode;
         this.level = level;
-        // Save a bit of processing time by constructing this closure in advance.
-        this.visitNode = (node) => node.visit(this);
-    }
-    // This method is defined to reconcile the type of TemplateBinder since both
-    // RecursiveAstVisitor and Visitor define the visit() method in their
-    // interfaces.
-    visit(node, context) {
-        if (node instanceof AST) {
-            node.visit(this, context);
-        }
-        else {
-            node.visit(this);
-        }
     }
     /**
      * Process a template and extract metadata about expressions and symbols within.
@@ -30656,14 +30622,6 @@ class TemplateBinder extends RecursiveAstVisitor {
             nodeOrNodes.forEach(this.visitNode);
         }
     }
-    visitElement(element) {
-        // Visit the inputs, outputs, and children of the element.
-        element.inputs.forEach(this.visitNode);
-        element.outputs.forEach(this.visitNode);
-        element.directives.forEach(this.visitNode);
-        element.children.forEach(this.visitNode);
-        element.references.forEach(this.visitNode);
-    }
     visitTemplate(template) {
         // First, visit inputs, outputs and template attributes of the template node.
         template.inputs.forEach(this.visitNode);
@@ -30686,34 +30644,6 @@ class TemplateBinder extends RecursiveAstVisitor {
             this.symbols.set(reference, this.rootNode);
         }
     }
-    visitComponent(component) {
-        component.inputs.forEach(this.visitNode);
-        component.outputs.forEach(this.visitNode);
-        component.directives.forEach(this.visitNode);
-        component.children.forEach(this.visitNode);
-        component.references.forEach(this.visitNode);
-    }
-    visitDirective(directive) {
-        directive.inputs.forEach(this.visitNode);
-        directive.outputs.forEach(this.visitNode);
-        directive.references.forEach(this.visitNode);
-    }
-    // Unused template visitors
-    visitText(text) { }
-    visitTextAttribute(attribute) { }
-    visitUnknownBlock(block) { }
-    visitDeferredTrigger() { }
-    visitIcu(icu) {
-        Object.keys(icu.vars).forEach((key) => icu.vars[key].visit(this));
-        Object.keys(icu.placeholders).forEach((key) => icu.placeholders[key].visit(this));
-    }
-    // The remaining visitors are concerned with processing AST expressions within template bindings
-    visitBoundAttribute(attribute) {
-        attribute.value.visit(this);
-    }
-    visitBoundEvent(event) {
-        event.handler.visit(this);
-    }
     visitDeferredBlock(deferred) {
         this.ingestScopedNode(deferred);
         deferred.triggers.when?.value.visit(this);
@@ -30733,10 +30663,6 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitDeferredBlockLoading(block) {
         this.ingestScopedNode(block);
     }
-    visitSwitchBlock(block) {
-        block.expression.visit(this);
-        block.cases.forEach(this.visitNode);
-    }
     visitSwitchBlockCase(block) {
         block.expression?.visit(this);
         this.ingestScopedNode(block);
@@ -30749,9 +30675,6 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitForLoopBlockEmpty(block) {
         this.ingestScopedNode(block);
     }
-    visitIfBlock(block) {
-        block.branches.forEach((node) => node.visit(this));
-    }
     visitIfBlockBranch(block) {
         block.expression?.visit(this);
         this.ingestScopedNode(block);
@@ -30759,11 +30682,8 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitContent(content) {
         this.ingestScopedNode(content);
     }
-    visitBoundText(text) {
-        text.value.visit(this);
-    }
     visitLetDeclaration(decl) {
-        decl.value.visit(this);
+        super.visitLetDeclaration(decl);
         if (this.rootNode !== null) {
             this.symbols.set(decl, this.rootNode);
         }
@@ -30785,10 +30705,6 @@ class TemplateBinder extends RecursiveAstVisitor {
         this.maybeMap(ast, ast.name);
         return super.visitSafePropertyRead(ast, context);
     }
-    visitPropertyWrite(ast, context) {
-        this.maybeMap(ast, ast.name);
-        return super.visitPropertyWrite(ast, context);
-    }
     ingestScopedNode(node) {
         const childScope = this.scope.getChildScope(node);
         const binder = new TemplateBinder(this.bindings, this.symbols, this.usedPipes, this.eagerPipes, this.deferBlocks, this.nestingLevel, childScope, node, this.level + 1);
@@ -31757,7 +31673,7 @@ class _Visitor {
         this._init(_VisitorMode.Merge, interpolationConfig);
         this._translations = translations;
         // Construct a single fake root element
-        const wrapper = new Element('wrapper', [], [], nodes, undefined, undefined, undefined);
+        const wrapper = new Element('wrapper', [], [], nodes, false, undefined, undefined, undefined);
         const translatedNode = wrapper.visit(this, null);
         if (this._inI18nBlock) {
             this._reportError(nodes[nodes.length - 1], 'Unclosed block');
@@ -31935,10 +31851,10 @@ class _Visitor {
         this._inImplicitNode = wasInImplicitNode;
         if (this._mode === _VisitorMode.Merge) {
             if (node instanceof Element) {
-                return new Element(node.name, this._translateAttributes(node), this._translateDirectives(node), childNodes, node.sourceSpan, node.startSourceSpan, node.endSourceSpan);
+                return new Element(node.name, this._translateAttributes(node), this._translateDirectives(node), childNodes, node.isSelfClosing, node.sourceSpan, node.startSourceSpan, node.endSourceSpan);
             }
             else {
-                return new Component(node.componentName, node.tagName, node.fullName, this._translateAttributes(node), this._translateDirectives(node), childNodes, node.sourceSpan, node.startSourceSpan, node.endSourceSpan);
+                return new Component(node.componentName, node.tagName, node.fullName, this._translateAttributes(node), this._translateDirectives(node), childNodes, node.isSelfClosing, node.sourceSpan, node.startSourceSpan, node.endSourceSpan);
             }
         }
         return null;
@@ -32166,7 +32082,7 @@ function isAttrNode(ast) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('20.0.1');
+new Version('20.1.0-next.0');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -32329,6 +32245,10 @@ exports.ErrorCode = void 0;
      * class used as a component).
      */
     ErrorCode[ErrorCode["INCORRECT_NAMED_TEMPLATE_DEPENDENCY_TYPE"] = 2025] = "INCORRECT_NAMED_TEMPLATE_DEPENDENCY_TYPE";
+    /**
+     * Raised for `@Component` fields that aren't supported in a selectorless context.
+     */
+    ErrorCode[ErrorCode["UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD"] = 2026] = "UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD";
     ErrorCode[ErrorCode["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
     /**
      * Raised when a relationship between directives and/or pipes would cause a cyclic import to be
@@ -33182,7 +33102,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-Bu1Wu4f7.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-CuQvkMhs.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.
@@ -38319,24 +38239,6 @@ class ExpressionTranslatorVisitor {
         this.setSourceMapRange(identifier, ast.sourceSpan);
         return identifier;
     }
-    visitWriteVarExpr(expr, context) {
-        const assignment = this.factory.createAssignment(this.setSourceMapRange(this.factory.createIdentifier(expr.name), expr.sourceSpan), expr.value.visitExpression(this, context));
-        return context.isStatement
-            ? assignment
-            : this.factory.createParenthesizedExpression(assignment);
-    }
-    visitWriteKeyExpr(expr, context) {
-        const exprContext = context.withExpressionMode;
-        const target = this.factory.createElementAccess(expr.receiver.visitExpression(this, exprContext), expr.index.visitExpression(this, exprContext));
-        const assignment = this.factory.createAssignment(target, expr.value.visitExpression(this, exprContext));
-        return context.isStatement
-            ? assignment
-            : this.factory.createParenthesizedExpression(assignment);
-    }
-    visitWritePropExpr(expr, context) {
-        const target = this.factory.createPropertyAccess(expr.receiver.visitExpression(this, context), expr.name);
-        return this.factory.createAssignment(target, expr.value.visitExpression(this, context));
-    }
     visitInvokeFunctionExpr(ast, context) {
         return this.setSourceMapRange(this.factory.createCallExpression(ast.fn.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)), ast.pure), ast.sourceSpan);
     }
@@ -38457,6 +38359,9 @@ 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]}`);
         }
@@ -38789,15 +38694,6 @@ class TypeTranslatorVisitor {
         }
         return ts.factory.createTypeQueryNode(ts.factory.createIdentifier(ast.name));
     }
-    visitWriteVarExpr(expr, context) {
-        throw new Error('Method not implemented.');
-    }
-    visitWriteKeyExpr(expr, context) {
-        throw new Error('Method not implemented.');
-    }
-    visitWritePropExpr(expr, context) {
-        throw new Error('Method not implemented.');
-    }
     visitInvokeFunctionExpr(ast, context) {
         throw new Error('Method not implemented.');
     }
@@ -39490,6 +39386,7 @@ exports.ComponentScopeKind = void 0;
 (function (ComponentScopeKind) {
     ComponentScopeKind[ComponentScopeKind["NgModule"] = 0] = "NgModule";
     ComponentScopeKind[ComponentScopeKind["Standalone"] = 1] = "Standalone";
+    ComponentScopeKind[ComponentScopeKind["Selectorless"] = 2] = "Selectorless";
 })(exports.ComponentScopeKind || (exports.ComponentScopeKind = {}));
 
 /**
@@ -39912,7 +39809,7 @@ const QUERY_TYPES = new Set(queryDecoratorNames);
  * appear in the declarations of an `NgModule` and additional verification is done when processing
  * the module.
  */
-function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, evaluator, refEmitter, referencesRegistry, isCore, annotateForClosureCompiler, compilationMode, defaultSelector, strictStandalone, implicitStandaloneValue) {
+function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, evaluator, refEmitter, referencesRegistry, isCore, annotateForClosureCompiler, compilationMode, defaultSelector, strictStandalone, implicitStandaloneValue, emitDeclarationOnly) {
     let directive;
     if (decorator.args === null || decorator.args.length === 0) {
         directive = new Map();
@@ -39938,8 +39835,8 @@ function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, ev
     const coreModule = isCore ? undefined : '@angular/core';
     // Construct the map of inputs both from the @Directive/@Component
     // decorator, and the decorated fields.
-    const inputsFromMeta = parseInputsArray(clazz, directive, evaluator, reflector, refEmitter, compilationMode);
-    const inputsFromFields = parseInputFields(clazz, members, evaluator, reflector, importTracker, refEmitter, isCore, compilationMode, inputsFromMeta, decorator);
+    const inputsFromMeta = parseInputsArray(clazz, directive, evaluator, reflector, refEmitter, compilationMode, emitDeclarationOnly);
+    const inputsFromFields = parseInputFields(clazz, members, evaluator, reflector, importTracker, refEmitter, isCore, compilationMode, inputsFromMeta, decorator, emitDeclarationOnly);
     const inputs = ClassPropertyMapping.fromMappedObject({ ...inputsFromMeta, ...inputsFromFields });
     // And outputs.
     const outputsFromMeta = parseOutputsArray(directive, evaluator);
@@ -40049,7 +39946,7 @@ function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, ev
     const rawHostDirectives = directive.get('hostDirectives') || null;
     const hostDirectives = rawHostDirectives === null
         ? null
-        : extractHostDirectives(rawHostDirectives, evaluator, compilationMode, createForwardRefResolver(isCore));
+        : extractHostDirectives(rawHostDirectives, evaluator, reflector, compilationMode, createForwardRefResolver(isCore), emitDeclarationOnly);
     if (compilationMode !== exports.CompilationMode.LOCAL && hostDirectives !== null) {
         // In global compilation mode where we do type checking, the template type-checker will need to
         // import host directive types, so add them as referenced by `clazz`. This will ensure that
@@ -40397,7 +40294,7 @@ function parseMappingString(value) {
     return [bindingPropertyName ?? fieldName, fieldName];
 }
 /** Parses the `inputs` array of a directive/component decorator. */
-function parseInputsArray(clazz, decoratorMetadata, evaluator, reflector, refEmitter, compilationMode) {
+function parseInputsArray(clazz, decoratorMetadata, evaluator, reflector, refEmitter, compilationMode, emitDeclarationOnly) {
     const inputsField = decoratorMetadata.get('inputs');
     if (inputsField === undefined) {
         return {};
@@ -40435,7 +40332,7 @@ function parseInputsArray(clazz, decoratorMetadata, evaluator, reflector, refEmi
                 if (!(transformValue instanceof DynamicValue) && !(transformValue instanceof Reference)) {
                     throw createValueHasWrongTypeError(inputsField, transformValue, `Transform of value at position ${i} of @Directive.inputs array must be a function`);
                 }
-                transform = parseDecoratorInputTransformFunction(clazz, name, transformValue, reflector, refEmitter, compilationMode);
+                transform = parseDecoratorInputTransformFunction(clazz, name, transformValue, reflector, refEmitter, compilationMode, emitDeclarationOnly);
             }
             inputs[name] = {
                 classPropertyName: name,
@@ -40464,7 +40361,7 @@ function tryGetDecoratorOnMember(member, decoratorName, isCore) {
     }
     return null;
 }
-function tryParseInputFieldMapping(clazz, member, evaluator, reflector, importTracker, isCore, refEmitter, compilationMode) {
+function tryParseInputFieldMapping(clazz, member, evaluator, reflector, importTracker, isCore, refEmitter, compilationMode, emitDeclarationOnly) {
     const classPropertyName = member.name;
     const decorator = tryGetDecoratorOnMember(member, 'Input', isCore);
     const signalInputMapping = tryParseSignalInputMapping(member, reflector, importTracker);
@@ -40502,7 +40399,7 @@ function tryParseInputFieldMapping(clazz, member, evaluator, reflector, importTr
             if (!(transformValue instanceof DynamicValue) && !(transformValue instanceof Reference)) {
                 throw createValueHasWrongTypeError(optionsNode, transformValue, `Input transform must be a function`);
             }
-            transform = parseDecoratorInputTransformFunction(clazz, classPropertyName, transformValue, reflector, refEmitter, compilationMode);
+            transform = parseDecoratorInputTransformFunction(clazz, classPropertyName, transformValue, reflector, refEmitter, compilationMode, emitDeclarationOnly);
         }
         return {
             isSignal: false,
@@ -40522,11 +40419,11 @@ function tryParseInputFieldMapping(clazz, member, evaluator, reflector, importTr
     return null;
 }
 /** Parses the class members that declare inputs (via decorator or initializer). */
-function parseInputFields(clazz, members, evaluator, reflector, importTracker, refEmitter, isCore, compilationMode, inputsFromClassDecorator, classDecorator) {
+function parseInputFields(clazz, members, evaluator, reflector, importTracker, refEmitter, isCore, compilationMode, inputsFromClassDecorator, classDecorator, emitDeclarationOnly) {
     const inputs = {};
     for (const member of members) {
         const classPropertyName = member.name;
-        const inputMapping = tryParseInputFieldMapping(clazz, member, evaluator, reflector, importTracker, isCore, refEmitter, compilationMode);
+        const inputMapping = tryParseInputFieldMapping(clazz, member, evaluator, reflector, importTracker, isCore, refEmitter, compilationMode, emitDeclarationOnly);
         if (inputMapping === null) {
             continue;
         }
@@ -40552,7 +40449,22 @@ function parseInputFields(clazz, members, evaluator, reflector, importTracker, r
  * automatically captured in the type of the `InputSignal`.
  *
  */
-function parseDecoratorInputTransformFunction(clazz, classPropertyName, value, reflector, refEmitter, compilationMode) {
+function parseDecoratorInputTransformFunction(clazz, classPropertyName, value, reflector, refEmitter, compilationMode, emitDeclarationOnly) {
+    if (emitDeclarationOnly) {
+        const chain = {
+            messageText: '@Input decorators with a transform function are not supported in experimental declaration-only emission mode',
+            category: ts.DiagnosticCategory.Error,
+            code: 0,
+            next: [
+                {
+                    messageText: `Consider converting '${clazz.name.text}.${classPropertyName}' to an input signal`,
+                    category: ts.DiagnosticCategory.Message,
+                    code: 0,
+                },
+            ],
+        };
+        throw new FatalDiagnosticError(exports.ErrorCode.DECORATOR_UNEXPECTED, value.node, chain);
+    }
     // In local compilation mode we can skip type checking the function args. This is because usually
     // the type check is done in a separate build which runs in full compilation mode. So here we skip
     // all the diagnostics.
@@ -40830,7 +40742,7 @@ function getHostBindingErrorNode(error, hostExpr) {
  * Extracts and prepares the host directives metadata from an array literal expression.
  * @param rawHostDirectives Expression that defined the `hostDirectives`.
  */
-function extractHostDirectives(rawHostDirectives, evaluator, compilationMode, forwardRefResolver) {
+function extractHostDirectives(rawHostDirectives, evaluator, reflector, compilationMode, forwardRefResolver, emitDeclarationOnly) {
     const resolved = evaluator.evaluate(rawHostDirectives, forwardRefResolver);
     if (!Array.isArray(resolved)) {
         throw createValueHasWrongTypeError(rawHostDirectives, resolved, 'hostDirectives must be an array');
@@ -40856,9 +40768,28 @@ function extractHostDirectives(rawHostDirectives, evaluator, compilationMode, fo
             // forward ref for imported symbols?!)
             if (!ts.isIdentifier(hostReference.node) &&
                 !ts.isPropertyAccessExpression(hostReference.node)) {
-                throw new FatalDiagnosticError(exports.ErrorCode.LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION, hostReference.node, `In local compilation mode, host directive cannot be an expression. Use an identifier instead`);
+                const compilationModeName = emitDeclarationOnly
+                    ? 'experimental declaration-only emission'
+                    : 'local compilation';
+                throw new FatalDiagnosticError(exports.ErrorCode.LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION, hostReference.node, `In ${compilationModeName} mode, host directive cannot be an expression. Use an identifier instead`);
+            }
+            if (emitDeclarationOnly) {
+                if (ts.isIdentifier(hostReference.node)) {
+                    const importInfo = reflector.getImportOfIdentifier(hostReference.node);
+                    if (importInfo) {
+                        directive = new ExternalReference(importInfo.from, importInfo.name);
+                    }
+                    else {
+                        throw new FatalDiagnosticError(exports.ErrorCode.LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION, hostReference.node, `In experimental declaration-only emission mode, host directive cannot use indirect external indentifiers. Use a direct external identifier instead`);
+                    }
+                }
+                else {
+                    throw new FatalDiagnosticError(exports.ErrorCode.LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION, hostReference.node, `In experimental declaration-only emission mode, host directive cannot be an expression. Use an identifier instead`);
+                }
+            }
+            else {
+                directive = new WrappedNodeExpr(hostReference.node);
             }
-            directive = new WrappedNodeExpr(hostReference.node);
         }
         else if (hostReference instanceof Reference) {
             directive = hostReference;
@@ -40898,6 +40829,12 @@ function toHostDirectiveMetadata(hostDirective, context, refEmitter) {
     if (hostDirective.directive instanceof Reference) {
         directive = toR3Reference(hostDirective.directive.node, hostDirective.directive, context, refEmitter);
     }
+    else if (hostDirective.directive instanceof ExternalReference) {
+        directive = {
+            value: new ExternalExpr(hostDirective.directive),
+            type: new ExternalExpr(hostDirective.directive),
+        };
+    }
     else {
         directive = {
             value: hostDirective.directive,
@@ -41117,6 +41054,8 @@ exports.SymbolKind = void 0;
     SymbolKind[SymbolKind["DomBinding"] = 9] = "DomBinding";
     SymbolKind[SymbolKind["Pipe"] = 10] = "Pipe";
     SymbolKind[SymbolKind["LetDeclaration"] = 11] = "LetDeclaration";
+    SymbolKind[SymbolKind["SelectorlessComponent"] = 12] = "SelectorlessComponent";
+    SymbolKind[SymbolKind["SelectorlessDirective"] = 13] = "SelectorlessDirective";
 })(exports.SymbolKind || (exports.SymbolKind = {}));
 
 /**
@@ -41414,6 +41353,10 @@ class CompletionEngine {
     tcbPath;
     tcbIsShim;
     componentContext;
+    /**
+     * Get the `TcbLocation` for the global context, which is the location of the `this` variable.
+     */
+    globalTsContext;
     /**
      * Cache of completions for various levels of the template, including the root template (`null`).
      * Memoizes `getTemplateContextCompletions`.
@@ -41439,11 +41382,20 @@ class CompletionEngine {
                 // for the component context.
                 positionInFile: globalRead.name.getStart(),
             };
+            this.globalTsContext = {
+                tcbPath: this.tcbPath,
+                isShimFile: this.tcbIsShim,
+                positionInFile: globalRead.name.getStart() - 1,
+            };
         }
         else {
             this.componentContext = null;
+            this.globalTsContext = null;
         }
     }
+    getGlobalTsContext() {
+        return this.globalTsContext;
+    }
     /**
      * Get global completions within the given template context and AST node.
      *
@@ -41499,7 +41451,7 @@ class CompletionEngine {
         }
         // Completion works inside property reads and method calls.
         let tsExpr = null;
-        if (expr instanceof PropertyRead || expr instanceof PropertyWrite) {
+        if (expr instanceof PropertyRead) {
             // Non-safe navigation operations are trivial: `foo.bar` or `foo.bar()`
             tsExpr = findFirstMatchingNode(this.tcb, {
                 filter: ts.isPropertyAccessExpression,
@@ -44463,10 +44415,11 @@ class OutOfBandDiagnosticRecorderImpl {
     missingNamedTemplateDependency(id, node) {
         this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), node.startSourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.MISSING_NAMED_TEMPLATE_DEPENDENCY), 
         // Wording is meant to mimic the wording TS uses in their diagnostic for missing symbols.
-        `Cannot find name "${node instanceof Directive$1 ? node.name : node.componentName}".`));
+        `Cannot find name "${node instanceof Directive$1 ? node.name : node.componentName}". ` +
+            `Selectorless references are only supported to classes or non-type import statements.`));
     }
     incorrectTemplateDependencyType(id, node) {
-        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), node.startSourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.INCORRECT_NAMED_TEMPLATE_DEPENDENCY_TYPE), `Incorrect reference type. Type must be an ${node instanceof Component$1 ? '@Component' : '@Directive'}.`));
+        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), node.startSourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.INCORRECT_NAMED_TEMPLATE_DEPENDENCY_TYPE), `Incorrect reference type. Type must be a standalone ${node instanceof Component$1 ? '@Component' : '@Directive'}.`));
     }
     unclaimedDirectiveBinding(id, directive, node) {
         const errorMsg = `Directive ${directive.name} does not have an ` +
@@ -44627,6 +44580,7 @@ const BINARY_OPS = new Map([
     ['>', ts.SyntaxKind.GreaterThanToken],
     ['<=', ts.SyntaxKind.LessThanEqualsToken],
     ['>=', ts.SyntaxKind.GreaterThanEqualsToken],
+    ['=', ts.SyntaxKind.EqualsToken],
     ['==', ts.SyntaxKind.EqualsEqualsToken],
     ['===', ts.SyntaxKind.EqualsEqualsEqualsToken],
     ['*', ts.SyntaxKind.AsteriskToken],
@@ -44737,16 +44691,6 @@ class AstTranslator {
         addParseSpanInfo(node, ast.sourceSpan);
         return node;
     }
-    visitKeyedWrite(ast) {
-        const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-        const left = ts.factory.createElementAccessExpression(receiver, this.translate(ast.key));
-        // TODO(joost): annotate `left` with the span of the element access, which is not currently
-        //  available on `ast`.
-        const right = wrapForTypeChecker(this.translate(ast.value));
-        const node = wrapForDiagnostics(ts.factory.createBinaryExpression(left, ts.SyntaxKind.EqualsToken, right));
-        addParseSpanInfo(node, ast.sourceSpan);
-        return node;
-    }
     visitLiteralArray(ast) {
         const elements = ast.expressions.map((expr) => this.translate(expr));
         const literal = ts.factory.createArrayLiteralExpression(elements);
@@ -44826,27 +44770,6 @@ class AstTranslator {
         addParseSpanInfo(node, ast.sourceSpan);
         return node;
     }
-    visitPropertyWrite(ast) {
-        const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-        const left = ts.factory.createPropertyAccessExpression(receiver, ast.name);
-        addParseSpanInfo(left, ast.nameSpan);
-        // TypeScript reports assignment errors on the entire lvalue expression. Annotate the lvalue of
-        // the assignment with the sourceSpan, which includes receivers, rather than nameSpan for
-        // consistency of the diagnostic location.
-        // a.b.c = 1
-        // ^^^^^^^^^ sourceSpan
-        //     ^     nameSpan
-        const leftWithPath = wrapForDiagnostics(left);
-        addParseSpanInfo(leftWithPath, ast.sourceSpan);
-        // The right needs to be wrapped in parens as well or we cannot accurately match its
-        // span to just the RHS. For example, the span in `e = $event /*0,10*/` is ambiguous.
-        // It could refer to either the whole binary expression or just the RHS.
-        // We should instead generate `e = ($event /*0,10*/)` so we know the span 0,10 matches RHS.
-        const right = wrapForTypeChecker(this.translate(ast.value));
-        const node = wrapForDiagnostics(ts.factory.createBinaryExpression(leftWithPath, ts.SyntaxKind.EqualsToken, right));
-        addParseSpanInfo(node, ast.sourceSpan);
-        return node;
-    }
     visitSafePropertyRead(ast) {
         let node;
         const receiver = wrapForDiagnostics(this.translate(ast.receiver));
@@ -45036,9 +44959,6 @@ class VeSafeLhsInferenceBugDetector {
     visitKeyedRead(ast) {
         return false;
     }
-    visitKeyedWrite(ast) {
-        return false;
-    }
     visitLiteralArray(ast) {
         return true;
     }
@@ -45066,9 +44986,6 @@ class VeSafeLhsInferenceBugDetector {
     visitPropertyRead(ast) {
         return false;
     }
-    visitPropertyWrite(ast) {
-        return false;
-    }
     visitSafePropertyRead(ast) {
         return false;
     }
@@ -47329,7 +47246,7 @@ class Scope {
             const directives = this.tcb.boundTarget.getDirectivesOfNode(directive);
             if (directives === null ||
                 directives.length === 0 ||
-                directives.some((dir) => dir.isComponent)) {
+                directives.some((dir) => dir.isComponent || !dir.isStandalone)) {
                 this.tcb.oobRecorder.incorrectTemplateDependencyType(this.tcb.id, directive);
                 continue;
             }
@@ -47402,7 +47319,7 @@ class Scope {
         const directives = this.tcb.boundTarget.getDirectivesOfNode(node);
         if (directives === null ||
             directives.length === 0 ||
-            directives.every((dir) => !dir.isComponent)) {
+            directives.every((dir) => !dir.isComponent || !dir.isStandalone)) {
             this.tcb.oobRecorder.incorrectTemplateDependencyType(this.tcb.id, node);
             return;
         }
@@ -47552,21 +47469,25 @@ class TcbExpressionTranslator {
             }
             return targetExpression;
         }
-        else if (ast instanceof PropertyWrite && ast.receiver instanceof ImplicitReceiver) {
-            const target = this.tcb.boundTarget.getExpressionTarget(ast);
+        else if (ast instanceof Binary &&
+            ast.operation === '=' &&
+            ast.left instanceof PropertyRead &&
+            ast.left.receiver instanceof ImplicitReceiver) {
+            const read = ast.left;
+            const target = this.tcb.boundTarget.getExpressionTarget(read);
             if (target === null) {
                 return null;
             }
-            const targetExpression = this.getTargetNodeExpression(target, ast);
-            const expr = this.translate(ast.value);
+            const targetExpression = this.getTargetNodeExpression(target, read);
+            const expr = this.translate(ast.right);
             const result = ts.factory.createParenthesizedExpression(ts.factory.createBinaryExpression(targetExpression, ts.SyntaxKind.EqualsToken, expr));
-            addParseSpanInfo(result, ast.sourceSpan);
+            addParseSpanInfo(result, read.sourceSpan);
             // Ignore diagnostics from TS produced for writes to `@let` and re-report them using
             // our own infrastructure. We can't rely on the TS reporting, because it includes
             // the name of the auto-generated TCB variable name.
             if (target instanceof LetDeclaration$1) {
                 markIgnoreDiagnostics(result);
-                this.tcb.oobRecorder.illegalWriteToLetDeclaration(this.tcb.id, ast, target);
+                this.tcb.oobRecorder.illegalWriteToLetDeclaration(this.tcb.id, read, target);
             }
             return result;
         }
@@ -48554,6 +48475,12 @@ class SymbolBuilder {
         else if (node instanceof Element$1) {
             symbol = this.getSymbolOfElement(node);
         }
+        else if (node instanceof Component$1) {
+            symbol = this.getSymbolOfSelectorlessComponent(node);
+        }
+        else if (node instanceof Directive$1) {
+            symbol = this.getSymbolOfSelectorlessDirective(node);
+        }
         else if (node instanceof Template) {
             symbol = this.getSymbolOfAstTemplate(node);
         }
@@ -48604,8 +48531,38 @@ class SymbolBuilder {
             templateNode: element,
         };
     }
-    getDirectivesOfNode(element) {
-        const elementSourceSpan = element.startSourceSpan ?? element.sourceSpan;
+    getSymbolOfSelectorlessComponent(node) {
+        const directives = this.getDirectivesOfNode(node);
+        const primaryDirective = directives.find((dir) => !dir.isHostDirective && dir.isComponent) ?? null;
+        if (primaryDirective === null) {
+            return null;
+        }
+        return {
+            tsType: primaryDirective.tsType,
+            tsSymbol: primaryDirective.tsSymbol,
+            tcbLocation: primaryDirective.tcbLocation,
+            kind: exports.SymbolKind.SelectorlessComponent,
+            directives,
+            templateNode: node,
+        };
+    }
+    getSymbolOfSelectorlessDirective(node) {
+        const directives = this.getDirectivesOfNode(node);
+        const primaryDirective = directives.find((dir) => !dir.isHostDirective && !dir.isComponent) ?? null;
+        if (primaryDirective === null) {
+            return null;
+        }
+        return {
+            tsType: primaryDirective.tsType,
+            tsSymbol: primaryDirective.tsSymbol,
+            tcbLocation: primaryDirective.tcbLocation,
+            kind: exports.SymbolKind.SelectorlessDirective,
+            directives,
+            templateNode: node,
+        };
+    }
+    getDirectivesOfNode(templateNode) {
+        const elementSourceSpan = templateNode.startSourceSpan ?? templateNode.sourceSpan;
         const tcbSourceFile = this.typeCheckBlock.getSourceFile();
         // directives could be either:
         // - var _t1: TestDir /*T:D*/ = null! as TestDir;
@@ -48618,6 +48575,7 @@ class SymbolBuilder {
             filter: isDirectiveDeclaration,
         });
         const symbols = [];
+        const seenDirectives = new Set();
         for (const node of nodes) {
             const symbol = this.getSymbolOfTsNode(node.parent);
             if (symbol === null ||
@@ -48625,11 +48583,14 @@ class SymbolBuilder {
                 !ts.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
                 continue;
             }
-            const meta = this.getDirectiveMeta(element, symbol.tsSymbol.valueDeclaration);
-            if (meta !== null && meta.selector !== null) {
-                const ref = new Reference(symbol.tsSymbol.valueDeclaration);
+            const declaration = symbol.tsSymbol.valueDeclaration;
+            const meta = this.getDirectiveMeta(templateNode, declaration);
+            // Host directives will be added as identifiers with the same offset as the host
+            // which means that they'll get added twice. De-duplicate them to avoid confusion.
+            if (meta !== null && !seenDirectives.has(declaration)) {
+                const ref = new Reference(declaration);
                 if (meta.hostDirectives !== null) {
-                    this.addHostDirectiveSymbols(element, meta.hostDirectives, symbols);
+                    this.addHostDirectiveSymbols(templateNode, meta.hostDirectives, symbols, seenDirectives);
                 }
                 const directiveSymbol = {
                     ...symbol,
@@ -48637,30 +48598,33 @@ class SymbolBuilder {
                     tsSymbol: symbol.tsSymbol,
                     selector: meta.selector,
                     isComponent: meta.isComponent,
-                    ngModule: this.getDirectiveModule(symbol.tsSymbol.valueDeclaration),
+                    ngModule: this.getDirectiveModule(declaration),
                     kind: exports.SymbolKind.Directive,
                     isStructural: meta.isStructural,
                     isInScope: true,
                     isHostDirective: false,
+                    tsCompletionEntryInfo: null,
                 };
                 symbols.push(directiveSymbol);
+                seenDirectives.add(declaration);
             }
         }
         return symbols;
     }
-    addHostDirectiveSymbols(host, hostDirectives, symbols) {
+    addHostDirectiveSymbols(host, hostDirectives, symbols, seenDirectives) {
         for (const current of hostDirectives) {
             if (!isHostDirectiveMetaForGlobalMode(current)) {
                 throw new Error('Impossible state: typecheck code path in local compilation mode.');
             }
-            if (!ts.isClassDeclaration(current.directive.node)) {
+            const node = current.directive.node;
+            if (!ts.isClassDeclaration(node) || seenDirectives.has(node)) {
                 continue;
             }
-            const symbol = this.getSymbolOfTsNode(current.directive.node);
-            const meta = this.getDirectiveMeta(host, current.directive.node);
+            const symbol = this.getSymbolOfTsNode(node);
+            const meta = this.getDirectiveMeta(host, node);
             if (meta !== null && symbol !== null && isSymbolWithValueDeclaration(symbol.tsSymbol)) {
                 if (meta.hostDirectives !== null) {
-                    this.addHostDirectiveSymbols(host, meta.hostDirectives, symbols);
+                    this.addHostDirectiveSymbols(host, meta.hostDirectives, symbols, seenDirectives);
                 }
                 const directiveSymbol = {
                     ...symbol,
@@ -48671,12 +48635,14 @@ class SymbolBuilder {
                     exposedOutputs: current.outputs,
                     selector: meta.selector,
                     isComponent: meta.isComponent,
-                    ngModule: this.getDirectiveModule(current.directive.node),
+                    ngModule: this.getDirectiveModule(node),
                     kind: exports.SymbolKind.Directive,
                     isStructural: meta.isStructural,
                     isInScope: true,
+                    tsCompletionEntryInfo: null,
                 };
                 symbols.push(directiveSymbol);
+                seenDirectives.add(node);
             }
         }
     }
@@ -48685,16 +48651,19 @@ class SymbolBuilder {
         // `getDirectivesOfNode` will not return the directives intended for an element
         // on a microsyntax template, for example `<div *ngFor="let user of users;" dir>`,
         // the `dir` will be skipped, but it's needed in language service.
-        const firstChild = host.children[0];
-        if (firstChild instanceof Element$1) {
-            const isMicrosyntaxTemplate = host instanceof Template && sourceSpanEqual(firstChild.sourceSpan, host.sourceSpan);
-            if (isMicrosyntaxTemplate) {
-                const firstChildDirectives = this.typeCheckData.boundTarget.getDirectivesOfNode(firstChild);
-                if (firstChildDirectives !== null && directives !== null) {
-                    directives = directives.concat(firstChildDirectives);
-                }
-                else {
-                    directives = directives ?? firstChildDirectives;
+        if (!(host instanceof Directive$1)) {
+            const firstChild = host.children[0];
+            if (firstChild instanceof Element$1) {
+                const isMicrosyntaxTemplate = host instanceof Template &&
+                    sourceSpanEqual(firstChild.sourceSpan, host.sourceSpan);
+                if (isMicrosyntaxTemplate) {
+                    const firstChildDirectives = this.typeCheckData.boundTarget.getDirectivesOfNode(firstChild);
+                    if (firstChildDirectives !== null && directives !== null) {
+                        directives = directives.concat(firstChildDirectives);
+                    }
+                    else {
+                        directives = directives ?? firstChildDirectives;
+                    }
                 }
             }
         }
@@ -48898,9 +48867,7 @@ class SymbolBuilder {
     getDirectiveSymbolForAccessExpression(fieldAccessExpr, { isComponent, selector, isStructural }) {
         // In all cases, `_t1["index"]` or `_t1.index`, `node.expression` is _t1.
         const tsSymbol = this.getTypeChecker().getSymbolAtLocation(fieldAccessExpr.expression);
-        if (tsSymbol?.declarations === undefined ||
-            tsSymbol.declarations.length === 0 ||
-            selector === null) {
+        if (tsSymbol?.declarations === undefined || tsSymbol.declarations.length === 0) {
             return null;
         }
         const [declaration] = tsSymbol.declarations;
@@ -48931,6 +48898,7 @@ class SymbolBuilder {
             ngModule,
             isHostDirective: false,
             isInScope: true, // TODO: this should always be in scope in this context, right?
+            tsCompletionEntryInfo: null,
         };
     }
     getSymbolOfVariable(variable) {
@@ -49087,11 +49055,15 @@ class SymbolBuilder {
             return this.getSymbol(expressionTarget);
         }
         let withSpan = expression.sourceSpan;
-        // The `name` part of a `PropertyWrite` and `ASTWithName` do not have their own
+        // The `name` part of a property write and `ASTWithName` do not have their own
         // 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 PropertyWrite ||
-            (expression instanceof ASTWithName && !(expression instanceof SafePropertyRead))) {
+        if (expression instanceof Binary &&
+            expression.operation === '=' &&
+            expression.left instanceof PropertyRead) {
+            withSpan = expression.left.nameSpan;
+        }
+        else if (expression instanceof ASTWithName && !(expression instanceof SafePropertyRead)) {
             withSpan = expression.nameSpan;
         }
         let node = null;
@@ -49703,37 +49675,44 @@ class TemplateTypeCheckerImpl {
         this.symbolBuilderCache.set(component, builder);
         return builder;
     }
-    getPotentialTemplateDirectives(component) {
-        const typeChecker = this.programDriver.getProgram().getTypeChecker();
-        const inScopeDirectives = this.getScopeData(component)?.directives ?? [];
-        const resultingDirectives = new Map();
-        // First, all in scope directives can be used.
-        for (const d of inScopeDirectives) {
-            resultingDirectives.set(d.ref.node, d);
+    getGlobalTsContext(component) {
+        const engine = this.getOrCreateCompletionEngine(component);
+        if (engine === null) {
+            return null;
         }
-        // Any additional directives found from the global registry can be used, but are not in scope.
-        // In the future, we can also walk other registries for .d.ts files, or traverse the
-        // import/export graph.
-        for (const directiveClass of this.localMetaReader.getKnown(exports.MetaKind.Directive)) {
-            const directiveMeta = this.metaReader.getDirectiveMetadata(new Reference(directiveClass));
-            if (directiveMeta === null)
-                continue;
-            if (resultingDirectives.has(directiveClass))
-                continue;
-            const withScope = this.scopeDataOfDirectiveMeta(typeChecker, directiveMeta);
-            if (withScope === null)
+        return engine.getGlobalTsContext();
+    }
+    getPotentialTemplateDirectives(component, tsLs, options) {
+        const scope = this.getComponentScope(component);
+        // Don't resolve directives for selectorless components since they're already in the file.
+        if (scope?.kind === exports.ComponentScopeKind.Selectorless) {
+            return [];
+        }
+        const resultingDirectives = new Map();
+        const directivesInScope = this.getTemplateDirectiveInScope(component);
+        const directiveInGlobal = this.getElementsInGlobal(component, tsLs, options);
+        for (const directive of [...directivesInScope, ...directiveInGlobal]) {
+            if (resultingDirectives.has(directive.ref.node)) {
                 continue;
-            resultingDirectives.set(directiveClass, { ...withScope, isInScope: false });
+            }
+            resultingDirectives.set(directive.ref.node, directive);
         }
         return Array.from(resultingDirectives.values());
     }
     getPotentialPipes(component) {
+        const scope = this.getComponentScope(component);
+        // Don't resolve pipes for selectorless components since they're already in the file.
+        if (scope?.kind === exports.ComponentScopeKind.Selectorless) {
+            return [];
+        }
         // Very similar to the above `getPotentialTemplateDirectives`, but on pipes.
         const typeChecker = this.programDriver.getProgram().getTypeChecker();
-        const inScopePipes = this.getScopeData(component)?.pipes ?? [];
         const resultingPipes = new Map();
-        for (const p of inScopePipes) {
-            resultingPipes.set(p.ref.node, p);
+        if (scope !== null) {
+            const inScopePipes = this.getScopeData(component, scope)?.pipes ?? [];
+            for (const p of inScopePipes) {
+                resultingPipes.set(p.ref.node, p);
+            }
         }
         for (const pipeClass of this.localMetaReader.getKnown(exports.MetaKind.Pipe)) {
             const pipeMeta = this.metaReader.getPipeMetadata(new Reference(pipeClass));
@@ -49766,7 +49745,156 @@ class TemplateTypeCheckerImpl {
         }
         return this.metaReader.getPipeMetadata(new Reference(pipe));
     }
-    getPotentialElementTags(component) {
+    getTemplateDirectiveInScope(component) {
+        const resultingDirectives = new Map();
+        const scope = this.getComponentScope(component);
+        // Don't resolve directives for selectorless components since they're already in the file.
+        if (scope?.kind === exports.ComponentScopeKind.Selectorless) {
+            return [];
+        }
+        if (scope !== null) {
+            const inScopeDirectives = this.getScopeData(component, scope)?.directives ?? [];
+            // First, all in scope directives can be used.
+            for (const d of inScopeDirectives) {
+                resultingDirectives.set(d.ref.node, d);
+            }
+        }
+        const typeChecker = this.programDriver.getProgram().getTypeChecker();
+        const currentComponentFileName = component.getSourceFile().fileName;
+        // Any additional directives found from the global registry can be used, only includes the directives includes in the current
+        // component file.
+        //
+        // This means only the inputs in the decorator are needed to be updated, no need to update the import statement.
+        for (const directiveClass of this.localMetaReader.getKnown(exports.MetaKind.Directive)) {
+            if (directiveClass.getSourceFile().fileName !== currentComponentFileName) {
+                continue;
+            }
+            const directiveMeta = this.metaReader.getDirectiveMetadata(new Reference(directiveClass));
+            if (directiveMeta === null)
+                continue;
+            if (resultingDirectives.has(directiveClass))
+                continue;
+            const withScope = this.scopeDataOfDirectiveMeta(typeChecker, directiveMeta);
+            if (withScope === null)
+                continue;
+            resultingDirectives.set(directiveClass, { ...withScope, isInScope: false });
+        }
+        return Array.from(resultingDirectives.values());
+    }
+    getDirectiveScopeData(component, isInScope, tsCompletionEntryInfo) {
+        const typeChecker = this.programDriver.getProgram().getTypeChecker();
+        if (!isNamedClassDeclaration(component)) {
+            return null;
+        }
+        const directiveMeta = this.metaReader.getDirectiveMetadata(new Reference(component));
+        if (directiveMeta === null) {
+            return null;
+        }
+        const withScope = this.scopeDataOfDirectiveMeta(typeChecker, directiveMeta);
+        if (withScope === null) {
+            return null;
+        }
+        return {
+            ...withScope,
+            isInScope,
+            tsCompletionEntryInfo,
+        };
+    }
+    getElementsInFileScope(component) {
+        const tagMap = new Map();
+        const potentialDirectives = this.getTemplateDirectiveInScope(component);
+        for (const directive of potentialDirectives) {
+            if (directive.selector === null) {
+                continue;
+            }
+            for (const selector of CssSelector.parse(directive.selector)) {
+                if (selector.element === null || tagMap.has(selector.element)) {
+                    // Skip this directive if it doesn't match an element tag, or if another directive has
+                    // already been included with the same element name.
+                    continue;
+                }
+                tagMap.set(selector.element, directive);
+            }
+        }
+        return tagMap;
+    }
+    getElementsInGlobal(component, tsLs, options) {
+        // Add the additional directives from the global registry, which are not in scope and in different file with the current
+        // component file.
+        //
+        // This means the inputs and the import statement in the decorator are needed to be updated.
+        const tsContext = this.getGlobalTsContext(component);
+        if (tsContext === null) {
+            return [];
+        }
+        if (!options.includeExternalModule) {
+            return [];
+        }
+        const entries = tsLs.getCompletionsAtPosition(tsContext.tcbPath, tsContext.positionInFile, {
+            includeSymbol: true,
+            includeCompletionsForModuleExports: true,
+        })?.entries;
+        const typeChecker = this.programDriver.getProgram().getTypeChecker();
+        const resultingDirectives = new Map();
+        const currentComponentFileName = component.getSourceFile().fileName;
+        for (const { symbol, data } of entries ?? []) {
+            const symbolFileName = symbol?.declarations?.[0]?.getSourceFile().fileName;
+            if (symbolFileName === undefined) {
+                continue;
+            }
+            if (symbolFileName === currentComponentFileName) {
+                continue;
+            }
+            const decl = getClassDeclFromSymbol(symbol, typeChecker);
+            if (decl === null) {
+                continue;
+            }
+            const directiveDecls = [];
+            const ref = new Reference(decl);
+            const directiveMeta = this.metaReader.getDirectiveMetadata(ref);
+            if (directiveMeta?.isStandalone) {
+                directiveDecls.push({
+                    meta: directiveMeta,
+                    ref,
+                });
+            }
+            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,
+                    });
+                }
+            }
+            for (const directiveDecl of directiveDecls) {
+                if (resultingDirectives.has(directiveDecl.ref.node)) {
+                    continue;
+                }
+                const withScope = this.scopeDataOfDirectiveMeta(typeChecker, directiveDecl.meta);
+                if (withScope === null) {
+                    continue;
+                }
+                resultingDirectives.set(directiveDecl.ref.node, {
+                    ...withScope,
+                    isInScope: false,
+                    tsCompletionEntryInfo: {
+                        tsCompletionEntryData: data,
+                        tsCompletionEntrySymbolFileName: symbolFileName,
+                    },
+                });
+            }
+        }
+        return Array.from(resultingDirectives.values());
+    }
+    getPotentialElementTags(component, tsLs, options) {
         if (this.elementTagCache.has(component)) {
             return this.elementTagCache.get(component);
         }
@@ -49774,7 +49902,7 @@ class TemplateTypeCheckerImpl {
         for (const tag of REGISTRY.allKnownElementNames()) {
             tagMap.set(tag, null);
         }
-        const potentialDirectives = this.getPotentialTemplateDirectives(component);
+        const potentialDirectives = this.getPotentialTemplateDirectives(component, tsLs, options);
         for (const directive of potentialDirectives) {
             if (directive.selector === null) {
                 continue;
@@ -49897,16 +50025,15 @@ class TemplateTypeCheckerImpl {
         }
         return imports;
     }
-    getScopeData(component) {
-        if (this.scopeCache.has(component)) {
-            return this.scopeCache.get(component);
-        }
+    getComponentScope(component) {
         if (!isNamedClassDeclaration(component)) {
             throw new Error(`AssertionError: components must have names`);
         }
-        const scope = this.componentScopeReader.getScopeForComponent(component);
-        if (scope === null) {
-            return null;
+        return this.componentScopeReader.getScopeForComponent(component);
+    }
+    getScopeData(component, scope) {
+        if (this.scopeCache.has(component)) {
+            return this.scopeCache.get(component);
         }
         const dependencies = scope.kind === exports.ComponentScopeKind.NgModule
             ? scope.compilation.dependencies
@@ -49957,6 +50084,7 @@ class TemplateTypeCheckerImpl {
             selector: dep.selector,
             tsSymbol,
             ngModule,
+            tsCompletionEntryInfo: null,
         };
     }
     scopeDataOfPipeMeta(typeChecker, dep) {
@@ -49968,6 +50096,7 @@ class TemplateTypeCheckerImpl {
             ref: dep.ref,
             name: dep.name,
             tsSymbol,
+            tsCompletionEntryInfo: null,
         };
     }
 }
@@ -50082,15 +50211,37 @@ class SingleShimTypeCheckingHost extends SingleFileTypeCheckingHost {
         return !this.fileData.shimData.has(shimPath);
     }
 }
+function getClassDeclFromSymbol(symbol, checker) {
+    const tsDecl = symbol?.getDeclarations();
+    if (tsDecl === undefined) {
+        return null;
+    }
+    let decl = tsDecl.length > 0 ? tsDecl[0] : undefined;
+    if (decl === undefined) {
+        return null;
+    }
+    if (ts.isExportAssignment(decl)) {
+        const symbol = checker.getTypeAtLocation(decl.expression).symbol;
+        return getClassDeclFromSymbol(symbol, checker);
+    }
+    if (ts.isExportSpecifier(decl)) {
+        const symbol = checker.getTypeAtLocation(decl).symbol;
+        return getClassDeclFromSymbol(symbol, checker);
+    }
+    if (isNamedClassDeclaration(decl)) {
+        return decl;
+    }
+    return null;
+}
 
 exports.AST = AST;
 exports.ASTWithSource = ASTWithSource;
 exports.AbsoluteModuleStrategy = AbsoluteModuleStrategy;
 exports.ArrowFunctionExpr = ArrowFunctionExpr;
 exports.Binary = Binary;
+exports.BindingPipe = BindingPipe;
 exports.BlockPlaceholder = BlockPlaceholder;
 exports.BoundAttribute = BoundAttribute;
-exports.BoundDeferredTrigger = BoundDeferredTrigger;
 exports.BoundEvent = BoundEvent;
 exports.COMPILER_ERRORS_WITH_GUIDES = COMPILER_ERRORS_WITH_GUIDES;
 exports.CR = CR;
@@ -50099,6 +50250,7 @@ exports.Call = Call;
 exports.Chain = Chain;
 exports.ClassPropertyMapping = ClassPropertyMapping;
 exports.CloneVisitor = CloneVisitor;
+exports.CombinedRecursiveAstVisitor = CombinedRecursiveAstVisitor;
 exports.Component = Component$1;
 exports.CompoundMetadataReader = CompoundMetadataReader;
 exports.Conditional = Conditional;
@@ -50154,7 +50306,6 @@ exports.ParseSourceSpan = ParseSourceSpan;
 exports.Parser = Parser$1;
 exports.Placeholder = Placeholder;
 exports.PropertyRead = PropertyRead;
-exports.PropertyWrite = PropertyWrite;
 exports.QUERY_INITIALIZER_FNS = QUERY_INITIALIZER_FNS;
 exports.R3TargetBinder = R3TargetBinder;
 exports.ReadVarExpr = ReadVarExpr;
@@ -50171,6 +50322,7 @@ exports.SafeCall = SafeCall;
 exports.SafeKeyedRead = SafeKeyedRead;
 exports.SafePropertyRead = SafePropertyRead;
 exports.SelectorMatcher = SelectorMatcher;
+exports.SelectorlessMatcher = SelectorlessMatcher;
 exports.Serializer = Serializer;
 exports.StaticInterpreter = StaticInterpreter;
 exports.SyntheticValue = SyntheticValue;