@angular/core 20.0.6 → 20.1.0-next.1

package/schematics/bundles/{index-jMQgXbRg.cjs → index-BUgQDm-J.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 /**
- * @license Angular v20.0.6
+ * @license Angular v20.1.0-next.1
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-var checker = require('./checker-a0VNmSrQ.cjs');
+var checker = require('./checker-CY7a8ko8.cjs');
 var ts = require('typescript');
 var p = require('path');
 require('os');
@@ -891,7 +891,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -909,7 +909,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? checker.literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? checker.literal(null));
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -1004,7 +1004,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', checker.literal(minVersion));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -1420,7 +1420,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -1455,7 +1455,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -1506,7 +1506,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -1539,7 +1539,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -1590,7 +1590,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', checker.literal('20.0.6'));
+    definitionMap.set('version', checker.literal('20.1.0-next.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -1598,7 +1598,7 @@ function createPipeDefinitionMap(meta) {
         definitionMap.set('isStandalone', checker.literal(meta.isStandalone));
     }
     // e.g. `name: "myPipe"`
-    definitionMap.set('name', checker.literal(meta.pipeName));
+    definitionMap.set('name', checker.literal(meta.pipeName ?? meta.name));
     if (meta.pure === false) {
         // e.g. `pure: false`
         definitionMap.set('pure', checker.literal(meta.pure));
@@ -2546,6 +2546,10 @@ class DtsMetadataReader {
             // used to increase the accuracy of a diagnostic.
             preserveWhitespaces: false,
             isExplicitlyDeferred: false,
+            // We don't need to know if imported components from .d.ts
+            // files are selectorless for type-checking purposes.
+            selectorlessEnabled: false,
+            localReferencedSymbols: null,
         };
     }
     /**
@@ -2567,11 +2571,12 @@ class DtsMetadataReader {
             return null;
         }
         const type = def.type.typeArguments[1];
-        if (!ts.isLiteralTypeNode(type) || !ts.isStringLiteral(type.literal)) {
+        if (!ts.isLiteralTypeNode(type) ||
+            (!ts.isStringLiteral(type.literal) && type.literal.kind !== ts.SyntaxKind.NullKeyword)) {
             // The type metadata was the wrong type.
             return null;
         }
-        const name = type.literal.text;
+        const name = ts.isStringLiteral(type.literal) ? type.literal.text : null;
         const isStandalone = def.type.typeArguments.length > 2 && (checker.readBooleanType(def.type.typeArguments[2]) ?? false);
         return {
             kind: checker.MetaKind.Pipe,
@@ -3187,6 +3192,7 @@ class TraitCompiler {
     dtsTransforms;
     semanticDepGraphUpdater;
     sourceFileTypeIdentifier;
+    emitDeclarationOnly;
     /**
      * Maps class declarations to their `ClassRecord`, which tracks the Ivy traits being applied to
      * those classes.
@@ -3204,7 +3210,7 @@ class TraitCompiler {
     filesWithoutTraits = new Set();
     reexportMap = new Map();
     handlersByName = new Map();
-    constructor(handlers, reflector, perf, incrementalBuild, compileNonExportedClasses, compilationMode, dtsTransforms, semanticDepGraphUpdater, sourceFileTypeIdentifier) {
+    constructor(handlers, reflector, perf, incrementalBuild, compileNonExportedClasses, compilationMode, dtsTransforms, semanticDepGraphUpdater, sourceFileTypeIdentifier, emitDeclarationOnly) {
         this.handlers = handlers;
         this.reflector = reflector;
         this.perf = perf;
@@ -3214,6 +3220,7 @@ class TraitCompiler {
         this.dtsTransforms = dtsTransforms;
         this.semanticDepGraphUpdater = semanticDepGraphUpdater;
         this.sourceFileTypeIdentifier = sourceFileTypeIdentifier;
+        this.emitDeclarationOnly = emitDeclarationOnly;
         for (const handler of handlers) {
             this.handlersByName.set(handler.name, handler);
         }
@@ -3422,13 +3429,16 @@ class TraitCompiler {
             record.metaDiagnostics === null) {
             // Custom decorators found in local compilation mode! In this mode we don't support custom
             // decorators yet. But will eventually do (b/320536434). For now a temporary error is thrown.
+            const compilationModeName = this.emitDeclarationOnly
+                ? 'experimental declaration-only emission'
+                : 'local compilation';
             record.metaDiagnostics = [...nonNgDecoratorsInLocalMode].map((decorator) => ({
                 category: ts.DiagnosticCategory.Error,
                 code: Number('-99' + checker.ErrorCode.DECORATOR_UNEXPECTED),
                 file: checker.getSourceFile(clazz),
                 start: decorator.node.getStart(),
                 length: decorator.node.getWidth(),
-                messageText: 'In local compilation mode, Angular does not support custom decorators. Ensure all class decorators are from Angular.',
+                messageText: `In ${compilationModeName} mode, Angular does not support custom decorators. Ensure all class decorators are from Angular.`,
             }));
             record.traits = foundTraits = [];
         }
@@ -3848,9 +3858,6 @@ class DtsTransformer {
             if (ts.isClassDeclaration(node)) {
                 return this.transformClassDeclaration(node, transforms, imports);
             }
-            else if (ts.isFunctionDeclaration(node)) {
-                return this.transformFunctionDeclaration(node, transforms, imports);
-            }
             else {
                 // Otherwise return node as is.
                 return ts.visitEachChild(node, visitor, this.ctx);
@@ -3862,52 +3869,13 @@ class DtsTransformer {
         return imports.transformTsFile(this.ctx, sf);
     }
     transformClassDeclaration(clazz, transforms, imports) {
-        let elements = clazz.members;
-        let elementsChanged = false;
-        for (const transform of transforms) {
-            if (transform.transformClassElement !== undefined) {
-                for (let i = 0; i < elements.length; i++) {
-                    const res = transform.transformClassElement(elements[i], imports);
-                    if (res !== elements[i]) {
-                        if (!elementsChanged) {
-                            elements = [...elements];
-                            elementsChanged = true;
-                        }
-                        elements[i] = res;
-                    }
-                }
-            }
-        }
         let newClazz = clazz;
         for (const transform of transforms) {
             if (transform.transformClass !== undefined) {
-                // If no DtsTransform has changed the class yet, then the (possibly mutated) elements have
-                // not yet been incorporated. Otherwise, `newClazz.members` holds the latest class members.
-                const inputMembers = clazz === newClazz ? elements : newClazz.members;
-                newClazz = transform.transformClass(newClazz, inputMembers, this.reflector, this.refEmitter, imports);
-            }
-        }
-        // If some elements have been transformed but the class itself has not been transformed, create
-        // an updated class declaration with the updated elements.
-        if (elementsChanged && clazz === newClazz) {
-            newClazz = ts.factory.updateClassDeclaration(
-            /* node */ clazz, 
-            /* modifiers */ clazz.modifiers, 
-            /* name */ clazz.name, 
-            /* typeParameters */ clazz.typeParameters, 
-            /* heritageClauses */ clazz.heritageClauses, 
-            /* members */ elements);
-        }
-        return newClazz;
-    }
-    transformFunctionDeclaration(declaration, transforms, imports) {
-        let newDecl = declaration;
-        for (const transform of transforms) {
-            if (transform.transformFunctionDeclaration !== undefined) {
-                newDecl = transform.transformFunctionDeclaration(newDecl, imports);
+                newClazz = transform.transformClass(newClazz, newClazz.members, this.reflector, this.refEmitter, imports);
             }
         }
-        return newDecl;
+        return newClazz;
     }
 }
 class IvyDeclarationDtsTransform {
@@ -4036,11 +4004,11 @@ class Visitor {
 
 const NO_DECORATORS = new Set();
 const CLOSURE_FILE_OVERVIEW_REGEXP = /\s+@fileoverview\s+/i;
-function ivyTransformFactory(compilation, reflector, importRewriter, defaultImportTracker, localCompilationExtraImportsTracker, perf, isCore, isClosureCompilerEnabled) {
+function ivyTransformFactory(compilation, reflector, importRewriter, defaultImportTracker, localCompilationExtraImportsTracker, perf, isCore, isClosureCompilerEnabled, emitDeclarationOnly) {
     const recordWrappedNode = createRecorderFn(defaultImportTracker);
     return (context) => {
         return (file) => {
-            return perf.inPhase(checker.PerfPhase.Compile, () => transformIvySourceFile(compilation, context, reflector, importRewriter, localCompilationExtraImportsTracker, file, isCore, isClosureCompilerEnabled, recordWrappedNode));
+            return perf.inPhase(checker.PerfPhase.Compile, () => transformIvySourceFile(compilation, context, reflector, importRewriter, localCompilationExtraImportsTracker, file, isCore, isClosureCompilerEnabled, emitDeclarationOnly, recordWrappedNode));
         };
     };
 }
@@ -4250,7 +4218,7 @@ class IvyTransformationVisitor extends Visitor {
 /**
  * A transformer which operates on ts.SourceFiles and applies changes from an `IvyCompilation`.
  */
-function transformIvySourceFile(compilation, context, reflector, importRewriter, localCompilationExtraImportsTracker, file, isCore, isClosureCompilerEnabled, recordWrappedNode) {
+function transformIvySourceFile(compilation, context, reflector, importRewriter, localCompilationExtraImportsTracker, file, isCore, isClosureCompilerEnabled, emitDeclarationOnly, recordWrappedNode) {
     const constantPool = new checker.ConstantPool(isClosureCompilerEnabled);
     const importManager = new checker.ImportManager({
         ...checker.presetImportManagerForceNamespaceImports,
@@ -4268,6 +4236,10 @@ function transformIvySourceFile(compilation, context, reflector, importRewriter,
     // Step 1. Go though all classes in AST, perform compilation and collect the results.
     const compilationVisitor = new IvyCompilationVisitor(compilation, constantPool);
     visit(file, compilationVisitor, context);
+    // If we are emitting declarations only, we can skip the script transforms.
+    if (emitDeclarationOnly) {
+        return file;
+    }
     // Step 2. Scan through the AST again and perform transformations based on Ivy compilation
     // results obtained at Step 1.
     const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore, compilationVisitor.deferrableImports);
@@ -4380,6 +4352,369 @@ function nodeArrayFromDecoratorsArray(decorators) {
     return array;
 }
 
+function insertDebugNameIntoCallExpression(callExpression, debugName) {
+    const signalExpressionHasNoArguments = callExpression.arguments.length === 0;
+    const signalExpressionIsRequired = isRequiredSignalFunction(callExpression.expression);
+    let configPosition = signalExpressionIsRequired ? 0 : 1;
+    // If the call expression has no arguments, we pretend that the config object is at position 0.
+    // We do this so that we can insert a spread element at the start of the args list in a way where
+    // undefined can be the first argument but still get tree-shaken out in production builds.
+    if (signalExpressionHasNoArguments) {
+        configPosition = 0;
+    }
+    const nodeArgs = Array.from(callExpression.arguments);
+    let existingArgument = nodeArgs[configPosition];
+    if (existingArgument === undefined) {
+        existingArgument = ts.factory.createObjectLiteralExpression([]);
+    }
+    // Do nothing if an identifier is used as the config object
+    // Ex -
+    // const defaultObject = { equals: () => false };
+    // signal(123, defaultObject)
+    if (ts.isIdentifier(existingArgument)) {
+        return callExpression;
+    }
+    if (!ts.isObjectLiteralExpression(existingArgument)) {
+        return callExpression;
+    }
+    // insert debugName into the existing config object
+    const properties = Array.from(existingArgument.properties);
+    const debugNameExists = properties.some((prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === 'debugName');
+    if (debugNameExists) {
+        return callExpression;
+    }
+    // We prepend instead of appending so that we don't overwrite an existing debugName Property
+    // `{ foo: 'bar' }` -> `{ debugName: 'myDebugName', foo: 'bar' }`
+    properties.unshift(ts.factory.createPropertyAssignment('debugName', ts.factory.createStringLiteral(debugName)));
+    const transformedConfigProperties = ts.factory.createObjectLiteralExpression(properties);
+    const ngDevModeIdentifier = ts.factory.createIdentifier('ngDevMode');
+    let devModeCase;
+    // if the signal expression has no arguments and the config object is not required,
+    // we need to add an undefined identifier to the start of the args list so that we can spread the
+    // config object in the right place.
+    if (signalExpressionHasNoArguments && !signalExpressionIsRequired) {
+        devModeCase = ts.factory.createArrayLiteralExpression([
+            ts.factory.createIdentifier('undefined'),
+            transformedConfigProperties,
+        ]);
+    }
+    else {
+        devModeCase = ts.factory.createArrayLiteralExpression([
+            transformedConfigProperties,
+            ...nodeArgs.slice(configPosition + 1),
+        ]);
+    }
+    const nonDevModeCase = signalExpressionIsRequired
+        ? ts.factory.createArrayLiteralExpression(nodeArgs)
+        : ts.factory.createArrayLiteralExpression(nodeArgs.slice(configPosition));
+    const spreadElementContainingUpdatedOptions = ts.factory.createSpreadElement(ts.factory.createParenthesizedExpression(ts.factory.createConditionalExpression(ngDevModeIdentifier, 
+    /* question token */ undefined, devModeCase, 
+    /* colon token */ undefined, nonDevModeCase)));
+    let transformedSignalArgs;
+    if (signalExpressionIsRequired || signalExpressionHasNoArguments) {
+        // 1. If the call expression is a required signal function, there is no args other than the config object.
+        // So we just use the spread element as the only argument.
+        // or
+        // 2. If the call expression has no arguments (ex. input(), model(), etc), we already added the undefined
+        // identifier in the spread element above. So we use that spread Element as is.
+        transformedSignalArgs = ts.factory.createNodeArray([spreadElementContainingUpdatedOptions]);
+    }
+    else {
+        // 3. Signal expression is not required and has arguments.
+        // Here we leave the first argument as is and spread the rest.
+        transformedSignalArgs = ts.factory.createNodeArray([
+            nodeArgs[0],
+            spreadElementContainingUpdatedOptions,
+        ]);
+    }
+    return ts.factory.updateCallExpression(callExpression, callExpression.expression, callExpression.typeArguments, transformedSignalArgs);
+}
+/**
+ *
+ * Determines if the node is a variable declaration with a call expression initializer.
+ * Ex:
+ * ```ts
+ * const mySignal = signal(123);
+ * ```
+ */
+function isVariableDeclarationCase(node) {
+    if (!ts.isVariableDeclaration(node)) {
+        return false;
+    }
+    if (!node.initializer || !ts.isCallExpression(node.initializer)) {
+        return false;
+    }
+    let expression = node.initializer.expression;
+    if (ts.isPropertyAccessExpression(expression)) {
+        expression = expression.expression;
+    }
+    return ts.isIdentifier(expression) && isSignalFunction(expression);
+}
+/**
+ *
+ * Determines if the node is a property assignment with a call expression initializer.
+ *
+ * Ex:
+ * ```ts
+ * class MyClass {
+ *   mySignal: Signal<number>;
+ *   constructor() {
+ *    this.mySignal = signal(123);
+ *   }
+ * }
+ * ```
+ */
+function isPropertyAssignmentCase(node) {
+    if (!ts.isExpressionStatement(node)) {
+        return false;
+    }
+    if (!ts.isBinaryExpression(node.expression)) {
+        return false;
+    }
+    const binaryExpression = node.expression;
+    if (binaryExpression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+        return false;
+    }
+    if (!ts.isCallExpression(binaryExpression.right)) {
+        return false;
+    }
+    if (!ts.isPropertyAccessExpression(binaryExpression.left)) {
+        return false;
+    }
+    let expression = binaryExpression.right.expression;
+    if (ts.isPropertyAccessExpression(expression)) {
+        expression = expression.expression;
+    }
+    return ts.isIdentifier(expression) && isSignalFunction(expression);
+}
+/**
+ *
+ * Determines if the node is a property declaration with a call expression initializer.
+ *
+ * Ex:
+ * ```ts
+ * class MyClass {
+ *   mySignal: Signal<number> = signal(123);
+ * }
+ * ```
+ */
+function isPropertyDeclarationCase(node) {
+    if (!ts.isPropertyDeclaration(node)) {
+        return false;
+    }
+    if (!(node.initializer && ts.isCallExpression(node.initializer))) {
+        return false;
+    }
+    let expression = node.initializer.expression;
+    if (ts.isPropertyAccessExpression(expression)) {
+        expression = expression.expression;
+    }
+    return ts.isIdentifier(expression) && isSignalFunction(expression);
+}
+/**
+ *
+ * Determines if a node is an expression that references an @angular/core imported symbol.
+ * Ex:
+ * ```ts
+ * import { signal } from '@angular/core';
+ * const mySignal = signal(123); // expressionIsUsingAngularImportedSymbol === true
+ * ```
+ */
+function expressionIsUsingAngularCoreImportedSymbol(program, expression) {
+    const symbol = program.getTypeChecker().getSymbolAtLocation(expression);
+    if (symbol === undefined) {
+        return false;
+    }
+    const declarations = symbol.declarations;
+    if (declarations === undefined || declarations.length === 0) {
+        return false;
+    }
+    // climb up the tree from the import specifier to the import declaration
+    const importSpecifier = declarations[0];
+    if (!ts.isImportSpecifier(importSpecifier)) {
+        return false;
+    }
+    const namedImports = importSpecifier.parent;
+    if (!ts.isNamedImports(namedImports)) {
+        return false;
+    }
+    const importsClause = namedImports.parent;
+    if (!ts.isImportClause(importsClause)) {
+        return false;
+    }
+    const importDeclaration = importsClause.parent;
+    if (!ts.isImportDeclaration(importDeclaration) ||
+        !ts.isStringLiteral(importDeclaration.moduleSpecifier)) {
+        return false;
+    }
+    const specifier = importDeclaration.moduleSpecifier.text;
+    return (specifier !== undefined &&
+        (specifier === '@angular/core' || specifier.startsWith('@angular/core/')));
+}
+const signalFunctions = new Set([
+    'signal',
+    'computed',
+    'input',
+    'model',
+    'viewChild',
+    'viewChildren',
+    'contentChild',
+    'contentChildren',
+    'effect',
+]);
+function isSignalFunction(expression) {
+    const text = expression.text;
+    return signalFunctions.has(text);
+}
+function isRequiredSignalFunction(expression) {
+    // Check for a property access expression that uses the 'required' property
+    if (ts.isPropertyAccessExpression(expression) &&
+        ts.isIdentifier(expression.name) &&
+        ts.isIdentifier(expression.expression)) {
+        const accessName = expression.name.text;
+        if (accessName === 'required') {
+            return true;
+        }
+    }
+    return false;
+}
+function transformVariableDeclaration(program, node) {
+    if (!node.initializer || !ts.isCallExpression(node.initializer))
+        return node;
+    const expression = node.initializer.expression;
+    if (ts.isPropertyAccessExpression(expression)) {
+        if (!expressionIsUsingAngularCoreImportedSymbol(program, expression.expression)) {
+            return node;
+        }
+    }
+    else if (!expressionIsUsingAngularCoreImportedSymbol(program, expression)) {
+        return node;
+    }
+    try {
+        // may throw if the node does not have a source file. Ignore this case for now
+        const nodeText = node.name.getText();
+        return ts.factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, insertDebugNameIntoCallExpression(node.initializer, nodeText));
+    }
+    catch {
+        return node;
+    }
+}
+function transformPropertyAssignment(program, node) {
+    const expression = node.expression.right.expression;
+    if (ts.isPropertyAccessExpression(expression)) {
+        if (!expressionIsUsingAngularCoreImportedSymbol(program, expression.expression)) {
+            return node;
+        }
+    }
+    else if (!expressionIsUsingAngularCoreImportedSymbol(program, expression)) {
+        return node;
+    }
+    return ts.factory.updateExpressionStatement(node, ts.factory.createBinaryExpression(node.expression.left, node.expression.operatorToken, insertDebugNameIntoCallExpression(node.expression.right, node.expression.left.name.text)));
+}
+function transformPropertyDeclaration(program, node) {
+    if (!node.initializer || !ts.isCallExpression(node.initializer))
+        return node;
+    const expression = node.initializer.expression;
+    if (ts.isPropertyAccessExpression(expression)) {
+        if (!expressionIsUsingAngularCoreImportedSymbol(program, expression.expression)) {
+            return node;
+        }
+    }
+    else if (!expressionIsUsingAngularCoreImportedSymbol(program, expression)) {
+        return node;
+    }
+    try {
+        // may throw if the node does not have a source file. Ignore this case for now.
+        const nodeText = node.name.getText();
+        return ts.factory.updatePropertyDeclaration(node, node.modifiers, node.name, node.questionToken, node.type, insertDebugNameIntoCallExpression(node.initializer, nodeText));
+    }
+    catch {
+        return node;
+    }
+}
+/**
+ *
+ * This transformer adds a debugName property to the config object of signal functions like
+ * signal, computed, effect, etc.
+ *
+ * The debugName property is added conditionally based on the value of ngDevMode. This is done
+ * to avoid adding the debugName property in production builds.
+ *
+ * Ex:
+ * ```ts
+ * import {signal} from '@angular/core';
+ * const mySignal = signal('Hello World');
+ * ```
+ *
+ * is transformed to:
+ * ```ts
+ * import {signal} from '@angular/core';
+ * const mySignal = signal('Hello World', ...(ngDevMode ? [{ debugName: "mySignal" }] : []));
+ * ```
+ *
+ * The transformer supports the following cases:
+ *
+ * # Variable declaration
+ * ```ts
+ * const mySignal = signal('Hello World');
+ * ```
+ *
+ * becomes
+ * ```
+ * const  mySignal = signal('Hello World', ...(ngDevMode ? [{ debugName: "mySignal" }] : []));
+ * ```
+ *
+ * # Property assignment
+ * ```ts
+ * class MyClass {
+ *  mySignal: Signal<string>;
+ *  constructor() {
+ *    this.mySignal = signal('Hello World');
+ *  }
+ * }
+ * ```
+ * becomes
+ * ```ts
+ * class MyClass {
+ *  mySignal: Signal<string>;
+ *  constructor() {
+ *   this.mySignal = signal(...(ngDevMode ? ['Hello World', { debugName: "mySignal" }] : ['Hello World']));
+ *  }
+ * }
+ * ```
+ *
+ * # Property declaration
+ * ```ts
+ * class MyClass {
+ *   mySignal = signal('Hello World');
+ * }
+ * ```
+ * becomes
+ * ```ts
+ * class MyClass {
+ *  mySignal = signal(...(ngDevMode ? ['Hello World', { debugName: "mySignal" }] : ['Hello World']));
+ * }
+ * ```
+ *
+ */
+function signalMetadataTransform(program) {
+    return (context) => (rootNode) => {
+        const visit = (node) => {
+            if (isVariableDeclarationCase(node)) {
+                return transformVariableDeclaration(program, node);
+            }
+            if (isPropertyAssignmentCase(node)) {
+                return transformPropertyAssignment(program, node);
+            }
+            if (isPropertyDeclarationCase(node)) {
+                return transformPropertyDeclaration(program, node);
+            }
+            return ts.visitEachChild(node, visit, context);
+        };
+        return ts.visitNode(rootNode, visit);
+    };
+}
+
 function resolveEnumValue(evaluator, metadata, field, enumSymbolName, isCore) {
     let resolved = null;
     if (metadata.has(field)) {
@@ -5880,6 +6215,111 @@ function reexportCollision(module, refA, refB) {
     ]);
 }
 
+/**
+ * Computes the scope for a selectorless component by looking at imports within the same
+ * file and resolving them to metadata.
+ */
+class SelectorlessComponentScopeReader {
+    metaReader;
+    reflector;
+    cache = new Map();
+    constructor(metaReader, reflector) {
+        this.metaReader = metaReader;
+        this.reflector = reflector;
+    }
+    getScopeForComponent(node) {
+        if (this.cache.has(node)) {
+            return this.cache.get(node);
+        }
+        const clazzRef = new checker.Reference(node);
+        const meta = this.metaReader.getDirectiveMetadata(clazzRef);
+        if (meta === null || !meta.isComponent || !meta.isStandalone || !meta.selectorlessEnabled) {
+            this.cache.set(node, null);
+            return null;
+        }
+        const eligibleIdentifiers = this.getAvailableIdentifiers(node);
+        const dependencies = new Map();
+        const dependencyIdentifiers = [];
+        let isPoisoned = meta.isPoisoned;
+        for (const [name, identifier] of eligibleIdentifiers) {
+            if (dependencies.has(name)) {
+                continue;
+            }
+            const dep = this.getMetaFromIdentifier(meta, name, identifier);
+            if (dep !== null) {
+                dependencies.set(name, dep);
+                dependencyIdentifiers.push(identifier);
+                if (dep.kind === checker.MetaKind.Directive && dep.isPoisoned) {
+                    isPoisoned = true;
+                }
+            }
+        }
+        const scope = {
+            kind: checker.ComponentScopeKind.Selectorless,
+            component: node,
+            dependencies,
+            dependencyIdentifiers,
+            isPoisoned,
+            schemas: meta.schemas ?? [],
+        };
+        this.cache.set(node, scope);
+        return scope;
+    }
+    getRemoteScope() {
+        return null;
+    }
+    /** Determines which identifiers a class has access to. */
+    getAvailableIdentifiers(node) {
+        const result = new Map();
+        let current = ts.getOriginalNode(node).parent;
+        while (current) {
+            // Note: doesn't account for some cases like function parameters,
+            // but we likely don't want to support those anyways.
+            if (!ts.isSourceFile(current) && !ts.isBlock(current)) {
+                current = current.parent;
+                continue;
+            }
+            for (const stmt of current.statements) {
+                if (this.reflector.isClass(stmt)) {
+                    result.set(stmt.name.text, stmt.name);
+                    continue;
+                }
+                if (ts.isImportDeclaration(stmt) &&
+                    stmt.importClause !== undefined &&
+                    !stmt.importClause.isTypeOnly) {
+                    const clause = stmt.importClause;
+                    if (clause.namedBindings !== undefined && ts.isNamedImports(clause.namedBindings)) {
+                        for (const element of clause.namedBindings.elements) {
+                            if (!element.isTypeOnly) {
+                                result.set(element.name.text, element.name);
+                            }
+                        }
+                    }
+                    if (clause.name !== undefined) {
+                        result.set(clause.name.text, clause.name);
+                    }
+                    continue;
+                }
+            }
+            current = current.parent;
+        }
+        return result;
+    }
+    getMetaFromIdentifier(meta, localName, node) {
+        // Consult the set of used names in the template so we don't hit the type checker for every
+        // import in the file. Most likely a subset of imports in the file will be used in the template.
+        if (meta.localReferencedSymbols === null || !meta.localReferencedSymbols.has(localName)) {
+            return null;
+        }
+        const declaration = this.reflector.getDeclarationOfIdentifier(node);
+        if (declaration === null || !this.reflector.isClass(declaration.node)) {
+            return null;
+        }
+        const ref = new checker.Reference(declaration.node);
+        return this.metaReader.getDirectiveMetadata(ref) ?? this.metaReader.getPipeMetadata(ref);
+    }
+}
+
 /**
  * Computes scope information to be used in template type checking.
  */
@@ -5907,13 +6347,12 @@ class TypeCheckScopeRegistry {
      * an empty type-check scope is returned.
      */
     getTypeCheckScope(node) {
-        const matcher = new checker.SelectorMatcher();
         const directives = [];
         const pipes = new Map();
         const scope = this.scopeReader.getScopeForComponent(node);
         if (scope === null) {
             return {
-                matcher,
+                matcher: null,
                 directives,
                 pipes,
                 schemas: [],
@@ -5921,36 +6360,40 @@ class TypeCheckScopeRegistry {
             };
         }
         const isNgModuleScope = scope.kind === checker.ComponentScopeKind.NgModule;
+        const isSelectorlessScope = scope.kind === checker.ComponentScopeKind.Selectorless;
         const cacheKey = isNgModuleScope ? scope.ngModule : scope.component;
-        const dependencies = isNgModuleScope ? scope.compilation.dependencies : scope.dependencies;
         if (this.scopeCache.has(cacheKey)) {
             return this.scopeCache.get(cacheKey);
         }
-        let allDependencies = dependencies;
-        if (!isNgModuleScope &&
-            Array.isArray(scope.deferredDependencies) &&
-            scope.deferredDependencies.length > 0) {
-            allDependencies = [...allDependencies, ...scope.deferredDependencies];
-        }
-        for (const meta of allDependencies) {
-            if (meta.kind === checker.MetaKind.Directive && meta.selector !== null) {
-                const extMeta = this.getTypeCheckDirectiveMetadata(meta.ref);
-                if (extMeta === null) {
-                    continue;
+        let matcher;
+        if (isSelectorlessScope) {
+            matcher = this.getSelectorlessMatcher(scope);
+            for (const [name, dep] of scope.dependencies) {
+                if (dep.kind === checker.MetaKind.Directive) {
+                    directives.push(dep);
+                }
+                else {
+                    // Pipes should be available under the imported name in selectorless.
+                    pipes.set(name, dep);
                 }
-                // Carry over the `isExplicitlyDeferred` flag from the dependency info.
-                const directiveMeta = this.applyExplicitlyDeferredFlag(extMeta, meta.isExplicitlyDeferred);
-                matcher.addSelectables(checker.CssSelector.parse(meta.selector), [
-                    ...this.hostDirectivesResolver.resolve(directiveMeta),
-                    directiveMeta,
-                ]);
-                directives.push(directiveMeta);
             }
-            else if (meta.kind === checker.MetaKind.Pipe) {
-                if (!ts.isClassDeclaration(meta.ref.node)) {
-                    throw new Error(`Unexpected non-class declaration ${ts.SyntaxKind[meta.ref.node.kind]} for pipe ${meta.ref.debugName}`);
+        }
+        else {
+            const dependencies = isNgModuleScope ? scope.compilation.dependencies : scope.dependencies;
+            let allDependencies = dependencies;
+            if (!isNgModuleScope &&
+                Array.isArray(scope.deferredDependencies) &&
+                scope.deferredDependencies.length > 0) {
+                allDependencies = [...allDependencies, ...scope.deferredDependencies];
+            }
+            matcher = this.getSelectorMatcher(allDependencies);
+            for (const dep of allDependencies) {
+                if (dep.kind === checker.MetaKind.Directive) {
+                    directives.push(dep);
+                }
+                else if (dep.kind === checker.MetaKind.Pipe && dep.name !== null) {
+                    pipes.set(dep.name, dep);
                 }
-                pipes.set(meta.name, meta);
             }
         }
         const typeCheckScope = {
@@ -5980,6 +6423,34 @@ class TypeCheckScopeRegistry {
     applyExplicitlyDeferredFlag(meta, isExplicitlyDeferred) {
         return isExplicitlyDeferred === true ? { ...meta, isExplicitlyDeferred } : meta;
     }
+    getSelectorMatcher(allDependencies) {
+        const matcher = new checker.SelectorMatcher();
+        for (const meta of allDependencies) {
+            if (meta.kind === checker.MetaKind.Directive && meta.selector !== null) {
+                const extMeta = this.getTypeCheckDirectiveMetadata(meta.ref);
+                if (extMeta === null) {
+                    continue;
+                }
+                // Carry over the `isExplicitlyDeferred` flag from the dependency info.
+                const directiveMeta = this.applyExplicitlyDeferredFlag(extMeta, meta.isExplicitlyDeferred);
+                matcher.addSelectables(checker.CssSelector.parse(meta.selector), [
+                    ...this.hostDirectivesResolver.resolve(directiveMeta),
+                    directiveMeta,
+                ]);
+            }
+        }
+        return matcher;
+    }
+    getSelectorlessMatcher(scope) {
+        const registry = new Map();
+        for (const [name, dep] of scope.dependencies) {
+            const extMeta = dep.kind === checker.MetaKind.Directive ? this.getTypeCheckDirectiveMetadata(dep.ref) : null;
+            if (extMeta !== null) {
+                registry.set(name, [extMeta, ...this.hostDirectivesResolver.resolve(extMeta)]);
+            }
+        }
+        return new checker.SelectorlessMatcher(registry);
+    }
 }
 
 /**
@@ -6599,7 +7070,8 @@ class DirectiveDecoratorHandler {
     implicitStandaloneValue;
     usePoisonedData;
     typeCheckHostBindings;
-    constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, annotateForClosureCompiler, perf, importTracker, includeClassMetadata, typeCheckScopeRegistry, compilationMode, jitDeclarationRegistry, resourceRegistry, strictStandalone, implicitStandaloneValue, usePoisonedData, typeCheckHostBindings) {
+    emitDeclarationOnly;
+    constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, annotateForClosureCompiler, perf, importTracker, includeClassMetadata, typeCheckScopeRegistry, compilationMode, jitDeclarationRegistry, resourceRegistry, strictStandalone, implicitStandaloneValue, usePoisonedData, typeCheckHostBindings, emitDeclarationOnly) {
         this.reflector = reflector;
         this.evaluator = evaluator;
         this.metaRegistry = metaRegistry;
@@ -6623,6 +7095,7 @@ class DirectiveDecoratorHandler {
         this.implicitStandaloneValue = implicitStandaloneValue;
         this.usePoisonedData = usePoisonedData;
         this.typeCheckHostBindings = typeCheckHostBindings;
+        this.emitDeclarationOnly = emitDeclarationOnly;
     }
     precedence = checker.HandlerPrecedence.PRIMARY;
     name = 'DirectiveDecoratorHandler';
@@ -6656,7 +7129,7 @@ class DirectiveDecoratorHandler {
         }
         this.perf.eventCount(checker.PerfEvent.AnalyzeDirective);
         const directiveResult = checker.extractDirectiveMetadata(node, decorator, this.reflector, this.importTracker, this.evaluator, this.refEmitter, this.referencesRegistry, this.isCore, this.annotateForClosureCompiler, this.compilationMode, 
-        /* defaultSelector */ null, this.strictStandalone, this.implicitStandaloneValue);
+        /* defaultSelector */ null, this.strictStandalone, this.implicitStandaloneValue, this.emitDeclarationOnly);
         // `extractDirectiveMetadata` returns `jitForced = true` when the `@Directive` has
         // set `jit: true`. In this case, compilation of the decorator is skipped. Returning
         // an empty object signifies that no analysis was produced.
@@ -6734,6 +7207,8 @@ class DirectiveDecoratorHandler {
             // Instead, we statically analyze their imports to make a direct determination.
             assumedToExportProviders: false,
             isExplicitlyDeferred: false,
+            selectorlessEnabled: false,
+            localReferencedSymbols: null,
         });
         this.resourceRegistry.registerResources(analysis.resources, node);
         this.injectableRegistry.registerInjectable(node, {
@@ -7063,7 +7538,8 @@ class NgModuleDecoratorHandler {
     compilationMode;
     localCompilationExtraImportsTracker;
     jitDeclarationRegistry;
-    constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, annotateForClosureCompiler, onlyPublishPublicTypings, injectableRegistry, perf, includeClassMetadata, includeSelectorScope, compilationMode, localCompilationExtraImportsTracker, jitDeclarationRegistry) {
+    emitDeclarationOnly;
+    constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, annotateForClosureCompiler, onlyPublishPublicTypings, injectableRegistry, perf, includeClassMetadata, includeSelectorScope, compilationMode, localCompilationExtraImportsTracker, jitDeclarationRegistry, emitDeclarationOnly) {
         this.reflector = reflector;
         this.evaluator = evaluator;
         this.metaReader = metaReader;
@@ -7083,6 +7559,7 @@ class NgModuleDecoratorHandler {
         this.compilationMode = compilationMode;
         this.localCompilationExtraImportsTracker = localCompilationExtraImportsTracker;
         this.jitDeclarationRegistry = jitDeclarationRegistry;
+        this.emitDeclarationOnly = emitDeclarationOnly;
     }
     precedence = checker.HandlerPrecedence.PRIMARY;
     name = 'NgModuleDecoratorHandler';
@@ -7127,13 +7604,14 @@ class NgModuleDecoratorHandler {
             createModuleWithProvidersResolver(this.reflector, this.isCore),
             forwardRefResolver,
         ]);
+        const allowUnresolvedReferences = this.compilationMode === checker.CompilationMode.LOCAL && !this.emitDeclarationOnly;
         const diagnostics = [];
         // Resolving declarations
         let declarationRefs = [];
         const rawDeclarations = ngModule.get('declarations') ?? null;
         if (rawDeclarations !== null) {
             const declarationMeta = this.evaluator.evaluate(rawDeclarations, forwardRefResolver);
-            declarationRefs = this.resolveTypeList(rawDeclarations, declarationMeta, name, 'declarations', 0, this.compilationMode === checker.CompilationMode.LOCAL).references;
+            declarationRefs = this.resolveTypeList(rawDeclarations, declarationMeta, name, 'declarations', 0, allowUnresolvedReferences).references;
             // Look through the declarations to make sure they're all a part of the current compilation.
             for (const ref of declarationRefs) {
                 if (ref.node.getSourceFile().isDeclarationFile) {
@@ -7150,7 +7628,7 @@ class NgModuleDecoratorHandler {
         let rawImports = ngModule.get('imports') ?? null;
         if (rawImports !== null) {
             const importsMeta = this.evaluator.evaluate(rawImports, moduleResolvers);
-            const result = this.resolveTypeList(rawImports, importsMeta, name, 'imports', 0, this.compilationMode === checker.CompilationMode.LOCAL);
+            const result = this.resolveTypeList(rawImports, importsMeta, name, 'imports', 0, allowUnresolvedReferences);
             if (this.compilationMode === checker.CompilationMode.LOCAL &&
                 this.localCompilationExtraImportsTracker !== null) {
                 // For generating extra imports in local mode, the NgModule imports that are from external
@@ -7173,13 +7651,13 @@ class NgModuleDecoratorHandler {
         const rawExports = ngModule.get('exports') ?? null;
         if (rawExports !== null) {
             const exportsMeta = this.evaluator.evaluate(rawExports, moduleResolvers);
-            exportRefs = this.resolveTypeList(rawExports, exportsMeta, name, 'exports', 0, this.compilationMode === checker.CompilationMode.LOCAL).references;
+            exportRefs = this.resolveTypeList(rawExports, exportsMeta, name, 'exports', 0, allowUnresolvedReferences).references;
             this.referencesRegistry.add(node, ...exportRefs);
         }
         // Resolving bootstrap
         let bootstrapRefs = [];
         const rawBootstrap = ngModule.get('bootstrap') ?? null;
-        if (this.compilationMode !== checker.CompilationMode.LOCAL && rawBootstrap !== null) {
+        if (!allowUnresolvedReferences && rawBootstrap !== null) {
             const bootstrapMeta = this.evaluator.evaluate(rawBootstrap, forwardRefResolver);
             bootstrapRefs = this.resolveTypeList(rawBootstrap, bootstrapMeta, name, 'bootstrap', 0, 
             /* allowUnresolvedReferences */ false).references;
@@ -7245,7 +7723,7 @@ class NgModuleDecoratorHandler {
             exports.some(isForwardReference);
         const type = checker.wrapTypeReference(this.reflector, node);
         let ngModuleMetadata;
-        if (this.compilationMode === checker.CompilationMode.LOCAL) {
+        if (allowUnresolvedReferences) {
             ngModuleMetadata = {
                 kind: checker.R3NgModuleMetadataKind.Local,
                 type,
@@ -7295,7 +7773,7 @@ class NgModuleDecoratorHandler {
                 : rawProviders);
         }
         const topLevelImports = [];
-        if (this.compilationMode !== checker.CompilationMode.LOCAL && ngModule.has('imports')) {
+        if (!allowUnresolvedReferences && ngModule.has('imports')) {
             const rawImports = checker.unwrapExpression(ngModule.get('imports'));
             let topLevelExpressions = [];
             if (ts.isArrayLiteralExpression(rawImports)) {
@@ -7332,7 +7810,7 @@ class NgModuleDecoratorHandler {
             providers: wrappedProviders,
             imports: [],
         };
-        if (this.compilationMode === checker.CompilationMode.LOCAL) {
+        if (allowUnresolvedReferences) {
             // Adding NgModule's raw imports/exports to the injector's imports field in local compilation
             // mode.
             for (const exp of [rawImports, rawExports]) {
@@ -7719,6 +8197,12 @@ class NgModuleDecoratorHandler {
                 dynamicValueSet.add(entry);
                 continue;
             }
+            else if (this.emitDeclarationOnly &&
+                entry instanceof checker.DynamicValue &&
+                entry.isFromUnknownIdentifier()) {
+                throw checker.createValueHasWrongTypeError(entry.node, entry, `Value at position ${absoluteIndex} in the NgModule.${arrayName} of ${className} is an external reference. ` +
+                    'External references in @NgModule declarations are not supported in experimental declaration-only emission mode');
+            }
             else {
                 // TODO(alxhub): Produce a better diagnostic here - the array index may be an inner array.
                 throw checker.createValueHasWrongTypeError(expr, entry, `Value at position ${absoluteIndex} in the NgModule.${arrayName} of ${className} is not a reference`);
@@ -8847,6 +9331,52 @@ class HmrModuleImportRewriter {
     }
 }
 
+/*!
+ * @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
+ */
+/**
+ * Analyzes a component's template to determine if it's using selectorless syntax
+ * and to extract the names of the selectorless symbols that are referenced.
+ */
+function analyzeTemplateForSelectorless(template) {
+    const analyzer = new SelectorlessDirectivesAnalyzer();
+    checker.visitAll(analyzer, template);
+    const isSelectorless = analyzer.symbols !== null && analyzer.symbols.size > 0;
+    const localReferencedSymbols = analyzer.symbols;
+    // The template is considered selectorless only if there
+    // are direct references to directives or pipes.
+    return { isSelectorless, localReferencedSymbols };
+}
+/**
+ * Visitor that traverses all the template nodes and
+ * expressions to look for selectorless references.
+ */
+class SelectorlessDirectivesAnalyzer extends checker.CombinedRecursiveAstVisitor {
+    symbols = null;
+    visit(node) {
+        if (node instanceof checker.BindingPipe && node.type === checker.BindingPipeType.ReferencedDirectly) {
+            this.trackSymbol(node.name);
+        }
+        super.visit(node);
+    }
+    visitComponent(component) {
+        this.trackSymbol(component.componentName);
+        super.visitComponent(component);
+    }
+    visitDirective(directive) {
+        this.trackSymbol(directive.name);
+        super.visitDirective(directive);
+    }
+    trackSymbol(name) {
+        this.symbols ??= new Set();
+        this.symbols.add(name);
+    }
+}
+
 const EMPTY_ARRAY = [];
 const isUsedDirective = (decl) => decl.kind === checker.R3TemplateDependencyKind.Directive;
 const isUsedPipe = (decl) => decl.kind === checker.R3TemplateDependencyKind.Pipe;
@@ -8899,7 +9429,8 @@ class ComponentDecoratorHandler {
     implicitStandaloneValue;
     typeCheckHostBindings;
     enableSelectorless;
-    constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, compilerHost, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf, hostDirectivesResolver, importTracker, includeClassMetadata, compilationMode, deferredSymbolTracker, forbidOrphanRendering, enableBlockSyntax, enableLetSyntax, externalRuntimeStyles, localCompilationExtraImportsTracker, jitDeclarationRegistry, i18nPreserveSignificantWhitespace, strictStandalone, enableHmr, implicitStandaloneValue, typeCheckHostBindings, enableSelectorless) {
+    emitDeclarationOnly;
+    constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, compilerHost, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf, hostDirectivesResolver, importTracker, includeClassMetadata, compilationMode, deferredSymbolTracker, forbidOrphanRendering, enableBlockSyntax, enableLetSyntax, externalRuntimeStyles, localCompilationExtraImportsTracker, jitDeclarationRegistry, i18nPreserveSignificantWhitespace, strictStandalone, enableHmr, implicitStandaloneValue, typeCheckHostBindings, enableSelectorless, emitDeclarationOnly) {
         this.reflector = reflector;
         this.evaluator = evaluator;
         this.metaRegistry = metaRegistry;
@@ -8945,6 +9476,7 @@ class ComponentDecoratorHandler {
         this.implicitStandaloneValue = implicitStandaloneValue;
         this.typeCheckHostBindings = typeCheckHostBindings;
         this.enableSelectorless = enableSelectorless;
+        this.emitDeclarationOnly = emitDeclarationOnly;
         this.extractTemplateOptions = {
             enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
             i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
@@ -9082,7 +9614,7 @@ class ComponentDecoratorHandler {
         let isPoisoned = false;
         // @Component inherits @Directive, so begin by extracting the @Directive metadata and building
         // on it.
-        const directiveResult = checker.extractDirectiveMetadata(node, decorator, this.reflector, this.importTracker, this.evaluator, this.refEmitter, this.referencesRegistry, this.isCore, this.annotateForClosureCompiler, this.compilationMode, this.elementSchemaRegistry.getDefaultComponentElementName(), this.strictStandalone, this.implicitStandaloneValue);
+        const directiveResult = checker.extractDirectiveMetadata(node, decorator, this.reflector, this.importTracker, this.evaluator, this.refEmitter, this.referencesRegistry, this.isCore, this.annotateForClosureCompiler, this.compilationMode, this.elementSchemaRegistry.getDefaultComponentElementName(), this.strictStandalone, this.implicitStandaloneValue, this.emitDeclarationOnly);
         // `extractDirectiveMetadata` returns `jitForced = true` when the `@Component` has
         // set `jit: true`. In this case, compilation of the decorator is skipped. Returning
         // an empty object signifies that no analysis was produced.
@@ -9262,6 +9794,25 @@ class ComponentDecoratorHandler {
                 node: template.sourceMapping.node,
             };
         const relativeTemplatePath = getProjectRelativePath(templateResource.path ?? ts.getOriginalNode(node).getSourceFile().fileName, this.rootDirs, this.compilerHost);
+        let selectorlessEnabled = false;
+        let localReferencedSymbols = null;
+        if (this.enableSelectorless) {
+            const templateAnalysis = analyzeTemplateForSelectorless(template.nodes);
+            selectorlessEnabled = templateAnalysis.isSelectorless;
+            localReferencedSymbols = templateAnalysis.localReferencedSymbols;
+        }
+        if (selectorlessEnabled) {
+            if (!metadata.isStandalone) {
+                isPoisoned = true;
+                diagnostics ??= [];
+                diagnostics.push(checker.makeDiagnostic(checker.ErrorCode.COMPONENT_NOT_STANDALONE, component.get('standalone') || node.name, `Cannot use selectorless with a component that is not standalone`));
+            }
+            else if (rawImports || rawDeferredImports) {
+                isPoisoned = true;
+                diagnostics ??= [];
+                diagnostics.push(checker.makeDiagnostic(checker.ErrorCode.UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD, (rawImports || rawDeferredImports), `Cannot use the "${rawImports === null ? 'deferredImports' : 'imports'}" field in a selectorless component`));
+            }
+        }
         // Figure out the set of styles. The ordering here is important: external resources (styleUrls)
         // precede inline styles, and styles defined in the template override styles defined in the
         // component.
@@ -9379,6 +9930,8 @@ class ComponentDecoratorHandler {
                 outputs,
                 hostDirectives,
                 rawHostDirectives,
+                selectorlessEnabled,
+                localReferencedSymbols,
                 meta: {
                     ...metadata,
                     template,
@@ -9464,6 +10017,8 @@ class ComponentDecoratorHandler {
             ngContentSelectors: analysis.template.ngContentSelectors,
             preserveWhitespaces: analysis.template.preserveWhitespaces ?? false,
             isExplicitlyDeferred: false,
+            selectorlessEnabled: analysis.selectorlessEnabled,
+            localReferencedSymbols: analysis.localReferencedSymbols,
         });
         this.resourceRegistry.registerResources(analysis.resources, node);
         this.injectableRegistry.registerInjectable(node, {
@@ -9476,25 +10031,19 @@ class ComponentDecoratorHandler {
         }
         const scope = this.scopeReader.getScopeForComponent(node);
         const selector = analysis.meta.selector;
-        const matcher = new checker.SelectorMatcher();
+        let matcher = null;
         if (scope !== null) {
-            let { dependencies, isPoisoned } = scope.kind === checker.ComponentScopeKind.NgModule ? scope.compilation : scope;
+            const isPoisoned = scope.kind === checker.ComponentScopeKind.NgModule
+                ? scope.compilation.isPoisoned
+                : scope.isPoisoned;
             if ((isPoisoned || (scope.kind === checker.ComponentScopeKind.NgModule && scope.exported.isPoisoned)) &&
                 !this.usePoisonedData) {
                 // Don't bother indexing components which had erroneous scopes, unless specifically
                 // requested.
-                return null;
-            }
-            for (const dep of dependencies) {
-                if (dep.kind === checker.MetaKind.Directive && dep.selector !== null) {
-                    matcher.addSelectables(checker.CssSelector.parse(dep.selector), [
-                        ...this.hostDirectivesResolver.resolve(dep),
-                        dep,
-                    ]);
-                }
+                return null;
             }
+            matcher = createMatcherFromScope(scope, this.hostDirectivesResolver);
         }
-        // TODO(crisbeto): implement for selectorless.
         const binder = new checker.R3TargetBinder(matcher);
         const boundTemplate = binder.bind({ template: analysis.template.diagNodes });
         context.addComponent({
@@ -9517,7 +10066,6 @@ class ComponentDecoratorHandler {
             // Don't type-check components that had errors in their scopes, unless requested.
             return;
         }
-        // TODO(crisbeto): implement for selectorless.
         const binder = new checker.R3TargetBinder(scope.matcher);
         const templateContext = {
             nodes: meta.template.diagNodes,
@@ -9608,8 +10156,8 @@ class ComponentDecoratorHandler {
             data.deferPerBlockDependencies = this.locateDeferBlocksWithoutScope(metadata.template);
         }
         else {
-            const { eagerlyUsed, deferBlocks, allDependencies, wholeTemplateUsed } = this.resolveComponentDependencies(node, context, analysis, scope, metadata, diagnostics);
-            const declarations = this.componentDependenciesToDeclarations(node, context, allDependencies, wholeTemplateUsed);
+            const { eagerlyUsed, deferBlocks, allDependencies, wholeTemplateUsed, pipes } = this.resolveComponentDependencies(node, context, analysis, scope, metadata, diagnostics);
+            const declarations = this.componentDependenciesToDeclarations(node, context, allDependencies, wholeTemplateUsed, pipes);
             if (this.semanticDepGraphUpdater !== null) {
                 const getSemanticReference = (decl) => this.semanticDepGraphUpdater.getSemanticReference(decl.ref.node, decl.type);
                 symbol.usedDirectives = Array.from(declarations.values())
@@ -9621,7 +10169,7 @@ class ComponentDecoratorHandler {
             }
             // Process information related to defer blocks
             if (this.compilationMode !== checker.CompilationMode.LOCAL) {
-                this.resolveDeferBlocks(node, deferBlocks, declarations, data, analysis, eagerlyUsed);
+                this.resolveDeferBlocks(node, scope, deferBlocks, declarations, data, analysis, eagerlyUsed);
             }
             this.handleDependencyCycles(node, context, scope, data, analysis, metadata, declarations, eagerlyUsed, symbol);
         }
@@ -9691,7 +10239,7 @@ class ComponentDecoratorHandler {
         if (perComponentDeferredDeps !== null) {
             removeDeferrableTypesFromComponentDecorator(analysis, perComponentDeferredDeps);
         }
-        const def = checker.compileComponentFromMetadata(meta, pool, checker.makeBindingParser());
+        const def = checker.compileComponentFromMetadata(meta, pool, this.getNewBindingParser());
         const inputTransformFields = compileInputTransformFields(analysis.inputs);
         const classMetadata = analysis.classMetadata !== null
             ? compileComponentClassMetadata(analysis.classMetadata, perComponentDeferredDeps).toStmt()
@@ -9759,7 +10307,7 @@ class ComponentDecoratorHandler {
             removeDeferrableTypesFromComponentDecorator(analysis, deferrableTypes);
         }
         const fac = compileNgFactoryDefField(checker.toFactoryMetadata(meta, checker.FactoryTarget.Component));
-        const def = checker.compileComponentFromMetadata(meta, pool, checker.makeBindingParser());
+        const def = checker.compileComponentFromMetadata(meta, pool, this.getNewBindingParser());
         const inputTransformFields = compileInputTransformFields(analysis.inputs);
         const classMetadata = analysis.classMetadata !== null
             ? compileComponentClassMetadata(analysis.classMetadata, deferrableTypes).toStmt()
@@ -9789,7 +10337,7 @@ class ComponentDecoratorHandler {
             defer,
         };
         const fac = compileNgFactoryDefField(checker.toFactoryMetadata(meta, checker.FactoryTarget.Component));
-        const def = checker.compileComponentFromMetadata(meta, pool, checker.makeBindingParser());
+        const def = checker.compileComponentFromMetadata(meta, pool, this.getNewBindingParser());
         const classMetadata = analysis.classMetadata !== null
             ? compileComponentClassMetadata(analysis.classMetadata, null).toStmt()
             : null;
@@ -9829,10 +10377,30 @@ class ComponentDecoratorHandler {
         // is an alternative implementation of template matching which is used for template
         // type-checking and will eventually replace matching in the TemplateDefinitionBuilder.
         const isModuleScope = scope.kind === checker.ComponentScopeKind.NgModule;
-        // Dependencies coming from the regular `imports` field.
-        const dependencies = isModuleScope ? scope.compilation.dependencies : scope.dependencies;
+        const isSelectorlessScope = scope.kind === checker.ComponentScopeKind.Selectorless;
+        const pipes = new Map();
         // Dependencies from the `@Component.deferredImports` field.
-        const explicitlyDeferredDependencies = getExplicitlyDeferredDeps(scope);
+        const explicitlyDeferredDependencies = scope.kind === checker.ComponentScopeKind.Standalone ? scope.deferredDependencies : null;
+        const dependencies = [];
+        if (isSelectorlessScope) {
+            for (const [localName, dep] of scope.dependencies) {
+                // In selectorless the pipes are referred to by their local name.
+                if (dep.kind === checker.MetaKind.Pipe) {
+                    pipes.set(localName, dep);
+                }
+                dependencies.push(dep);
+            }
+        }
+        else {
+            const scopeDeps = isModuleScope ? scope.compilation.dependencies : scope.dependencies;
+            for (const dep of scopeDeps) {
+                // Outside of selectorless the pipes are referred to by their defined name.
+                if (dep.kind === checker.MetaKind.Pipe && dep.name !== null) {
+                    pipes.set(dep.name, dep);
+                }
+                dependencies.push(dep);
+            }
+        }
         // Mark the component is an NgModule-based component with its NgModule in a different file
         // then mark this file for extra import generation
         if (isModuleScope && context.fileName !== checker.getSourceFile(scope.ngModule).fileName) {
@@ -9840,8 +10408,10 @@ class ComponentDecoratorHandler {
         }
         // Make sure that `@Component.imports` and `@Component.deferredImports` do not have
         // the same dependencies.
-        if (metadata.isStandalone &&
+        if (!isSelectorlessScope &&
+            metadata.isStandalone &&
             analysis.rawDeferredImports !== null &&
+            explicitlyDeferredDependencies !== null &&
             explicitlyDeferredDependencies.length > 0) {
             const diagnostic = validateNoImportOverlap(dependencies, explicitlyDeferredDependencies, analysis.rawDeferredImports);
             if (diagnostic !== null) {
@@ -9849,7 +10419,7 @@ class ComponentDecoratorHandler {
             }
         }
         // Set up the R3TargetBinder.
-        const binder = createTargetBinder(dependencies);
+        const binder = new checker.R3TargetBinder(createMatcherFromScope(scope, this.hostDirectivesResolver));
         let allDependencies = dependencies;
         let deferBlockBinder = binder;
         // If there are any explicitly deferred dependencies (via `@Component.deferredImports`),
@@ -9858,13 +10428,19 @@ class ComponentDecoratorHandler {
         // and need to be referenced later when determining what dependencies need to be in a
         // defer function / instruction call. Otherwise they end up treated as a standard
         // import, which is wrong.
-        if (explicitlyDeferredDependencies.length > 0) {
+        if (explicitlyDeferredDependencies !== null && explicitlyDeferredDependencies.length > 0) {
             allDependencies = [...explicitlyDeferredDependencies, ...dependencies];
-            deferBlockBinder = createTargetBinder(allDependencies);
+            const deferBlockMatcher = new checker.SelectorMatcher();
+            for (const dep of allDependencies) {
+                if (dep.kind === checker.MetaKind.Pipe && dep.name !== null) {
+                    pipes.set(dep.name, dep);
+                }
+                else if (dep.kind === checker.MetaKind.Directive && dep.selector !== null) {
+                    deferBlockMatcher.addSelectables(checker.CssSelector.parse(dep.selector), [dep]);
+                }
+            }
+            deferBlockBinder = new checker.R3TargetBinder(deferBlockMatcher);
         }
-        // Set up the pipes map that is later used to determine which dependencies are used in
-        // the template.
-        const pipes = extractPipes(allDependencies);
         // Next, the component template AST is bound using the R3TargetBinder. This produces a
         // BoundTarget, which is similar to a ts.TypeChecker.
         const bound = binder.bind({ template: metadata.template.nodes });
@@ -9916,13 +10492,13 @@ class ComponentDecoratorHandler {
                 wholeTemplateUsed.add(pipes.get(name).ref.node);
             }
         }
-        return { allDependencies, eagerlyUsed, wholeTemplateUsed, deferBlocks };
+        return { allDependencies, eagerlyUsed, wholeTemplateUsed, deferBlocks, pipes };
     }
     /**
      * Converts component dependencies into declarations by
      * resolving their metadata and deduplicating them.
      */
-    componentDependenciesToDeclarations(node, context, allDependencies, wholeTemplateUsed) {
+    componentDependenciesToDeclarations(node, context, allDependencies, wholeTemplateUsed, pipes) {
         const declarations = new Map();
         // Transform the dependencies list, filtering out unused dependencies.
         for (const dep of allDependencies) {
@@ -9949,20 +10525,6 @@ class ComponentDecoratorHandler {
                         isComponent: dep.isComponent,
                     });
                     break;
-                case checker.MetaKind.Pipe:
-                    if (!wholeTemplateUsed.has(dep.ref.node)) {
-                        continue;
-                    }
-                    const pipeType = this.refEmitter.emit(dep.ref, context);
-                    checker.assertSuccessfulReferenceEmit(pipeType, node.name, 'pipe');
-                    declarations.set(dep.ref.node, {
-                        kind: checker.R3TemplateDependencyKind.Pipe,
-                        type: pipeType.expression,
-                        name: dep.name,
-                        ref: dep.ref,
-                        importedFile: pipeType.importedFile,
-                    });
-                    break;
                 case checker.MetaKind.NgModule:
                     const ngModuleType = this.refEmitter.emit(dep.ref, context);
                     checker.assertSuccessfulReferenceEmit(ngModuleType, node.name, 'NgModule');
@@ -9974,6 +10536,21 @@ class ComponentDecoratorHandler {
                     break;
             }
         }
+        for (const [localName, dep] of pipes) {
+            if (!wholeTemplateUsed.has(dep.ref.node)) {
+                continue;
+            }
+            const pipeType = this.refEmitter.emit(dep.ref, context);
+            checker.assertSuccessfulReferenceEmit(pipeType, node.name, 'pipe');
+            declarations.set(dep.ref.node, {
+                kind: checker.R3TemplateDependencyKind.Pipe,
+                type: pipeType.expression,
+                // Use the local name for pipes to account for selectorless.
+                name: localName,
+                ref: dep.ref,
+                importedFile: pipeType.importedFile,
+            });
+        }
         return declarations;
     }
     /** Handles any cycles in the dependencies of a component. */
@@ -10211,7 +10788,7 @@ class ComponentDecoratorHandler {
      * Resolves information about defer blocks dependencies to make it
      * available for the final `compile` step.
      */
-    resolveDeferBlocks(componentClassDecl, deferBlocks, deferrableDecls, resolutionData, analysisData, eagerlyUsedDecls) {
+    resolveDeferBlocks(componentClassDecl, scope, deferBlocks, deferrableDecls, resolutionData, analysisData, eagerlyUsedDecls) {
         // Collect all deferred decls from all defer blocks from the entire template
         // to intersect with the information from the `imports` field of a particular
         // Component.
@@ -10252,15 +10829,27 @@ class ComponentDecoratorHandler {
                 allDeferredDecls.add(decl.ref.node);
             }
         }
-        // For standalone components with the `imports` and `deferredImports` fields -
-        // inspect the list of referenced symbols and mark the ones used in defer blocks
-        // as potential candidates for defer loading.
         if (analysisData.meta.isStandalone) {
-            if (analysisData.rawImports !== null) {
-                this.registerDeferrableCandidates(componentClassDecl, analysisData.rawImports, false /* isDeferredImport */, allDeferredDecls, eagerlyUsedDecls, resolutionData);
+            // For standalone components with the `imports` and `deferredImports` fields -
+            // inspect the list of referenced symbols and mark the ones used in defer blocks
+            // as potential candidates for defer loading.
+            if (analysisData.rawImports !== null &&
+                ts.isArrayLiteralExpression(analysisData.rawImports)) {
+                for (const element of analysisData.rawImports.elements) {
+                    this.registerDeferrableCandidate(componentClassDecl, element, false /* isDeferredImport */, allDeferredDecls, eagerlyUsedDecls, resolutionData);
+                }
             }
-            if (analysisData.rawDeferredImports !== null) {
-                this.registerDeferrableCandidates(componentClassDecl, analysisData.rawDeferredImports, true /* isDeferredImport */, allDeferredDecls, eagerlyUsedDecls, resolutionData);
+            if (analysisData.rawDeferredImports !== null &&
+                ts.isArrayLiteralExpression(analysisData.rawDeferredImports)) {
+                for (const element of analysisData.rawDeferredImports.elements) {
+                    this.registerDeferrableCandidate(componentClassDecl, element, false /* isDeferredImport */, allDeferredDecls, eagerlyUsedDecls, resolutionData);
+                }
+            }
+            // Selectorless references dependencies directly so we register through the identifiers.
+            if (scope.kind === checker.ComponentScopeKind.Selectorless) {
+                for (const identifier of scope.dependencyIdentifiers) {
+                    this.registerDeferrableCandidate(componentClassDecl, identifier, false /* isDeferredImport */, allDeferredDecls, eagerlyUsedDecls, resolutionData);
+                }
             }
         }
     }
@@ -10269,58 +10858,53 @@ class ComponentDecoratorHandler {
      * `@Component.deferredImports`) and registers imported types as deferrable
      * candidates.
      */
-    registerDeferrableCandidates(componentClassDecl, importsExpr, isDeferredImport, allDeferredDecls, eagerlyUsedDecls, resolutionData) {
-        if (!ts.isArrayLiteralExpression(importsExpr)) {
+    registerDeferrableCandidate(componentClassDecl, element, isDeferredImport, allDeferredDecls, eagerlyUsedDecls, resolutionData) {
+        const node = checker.tryUnwrapForwardRef(element, this.reflector) || element;
+        if (!ts.isIdentifier(node)) {
+            // Can't defer-load non-literal references.
             return;
         }
-        for (const element of importsExpr.elements) {
-            const node = checker.tryUnwrapForwardRef(element, this.reflector) || element;
-            if (!ts.isIdentifier(node)) {
-                // Can't defer-load non-literal references.
-                continue;
-            }
-            const imp = this.reflector.getImportOfIdentifier(node);
-            if (imp === null) {
-                // Can't defer-load symbols which aren't imported.
-                continue;
-            }
-            const decl = this.reflector.getDeclarationOfIdentifier(node);
-            if (decl === null) {
-                // Can't defer-load symbols which don't exist.
-                continue;
-            }
-            if (!checker.isNamedClassDeclaration(decl.node)) {
-                // Can't defer-load symbols which aren't classes.
-                continue;
-            }
-            // Are we even trying to defer-load this symbol?
-            if (!allDeferredDecls.has(decl.node)) {
-                continue;
-            }
-            if (eagerlyUsedDecls.has(decl.node)) {
-                // Can't defer-load symbols that are eagerly referenced as a dependency
-                // in a template outside of a defer block.
-                continue;
-            }
-            // Is it a standalone directive/component?
-            const dirMeta = this.metaReader.getDirectiveMetadata(new checker.Reference(decl.node));
-            if (dirMeta !== null && !dirMeta.isStandalone) {
-                continue;
-            }
-            // Is it a standalone pipe?
-            const pipeMeta = this.metaReader.getPipeMetadata(new checker.Reference(decl.node));
-            if (pipeMeta !== null && !pipeMeta.isStandalone) {
-                continue;
-            }
-            if (dirMeta === null && pipeMeta === null) {
-                // This is not a directive or a pipe.
-                continue;
-            }
-            // Keep track of how this class made it into the current source file
-            // (which ts.ImportDeclaration was used for this symbol).
-            resolutionData.deferrableDeclToImportDecl.set(decl.node, imp.node);
-            this.deferredSymbolTracker.markAsDeferrableCandidate(node, imp.node, componentClassDecl, isDeferredImport);
+        const imp = this.reflector.getImportOfIdentifier(node);
+        if (imp === null) {
+            // Can't defer-load symbols which aren't imported.
+            return;
+        }
+        const decl = this.reflector.getDeclarationOfIdentifier(node);
+        if (decl === null) {
+            // Can't defer-load symbols which don't exist.
+            return;
+        }
+        if (!checker.isNamedClassDeclaration(decl.node)) {
+            // Can't defer-load symbols which aren't classes.
+            return;
+        }
+        // Are we even trying to defer-load this symbol?
+        if (!allDeferredDecls.has(decl.node)) {
+            return;
+        }
+        if (eagerlyUsedDecls.has(decl.node)) {
+            // Can't defer-load symbols that are eagerly referenced as a dependency
+            // in a template outside of a defer block.
+            return;
+        }
+        // Is it a standalone directive/component?
+        const dirMeta = this.metaReader.getDirectiveMetadata(new checker.Reference(decl.node));
+        if (dirMeta !== null && !dirMeta.isStandalone) {
+            return;
+        }
+        // Is it a standalone pipe?
+        const pipeMeta = this.metaReader.getPipeMetadata(new checker.Reference(decl.node));
+        if (pipeMeta !== null && !pipeMeta.isStandalone) {
+            return;
+        }
+        if (dirMeta === null && pipeMeta === null) {
+            // This is not a directive or a pipe.
+            return;
         }
+        // Keep track of how this class made it into the current source file
+        // (which ts.ImportDeclaration was used for this symbol).
+        resolutionData.deferrableDeclToImportDecl.set(decl.node, imp.node);
+        this.deferredSymbolTracker.markAsDeferrableCandidate(node, imp.node, componentClassDecl, isDeferredImport);
     }
     compileDeferBlocks(resolution) {
         const { deferBlockDepsEmitMode: mode, deferPerBlockDependencies: perBlockDeps, deferPerComponentDependencies: perComponentDeps, } = resolution;
@@ -10347,36 +10931,31 @@ class ComponentDecoratorHandler {
         }
         throw new Error(`Invalid deferBlockDepsEmitMode. Cannot compile deferred block metadata.`);
     }
+    /** Creates a new binding parser. */
+    getNewBindingParser() {
+        return checker.makeBindingParser(undefined, this.enableSelectorless);
+    }
 }
-/**
- * Creates an instance of a target binder based on provided dependencies.
- */
-function createTargetBinder(dependencies) {
+function createMatcherFromScope(scope, hostDirectivesResolver) {
+    if (scope.kind === checker.ComponentScopeKind.Selectorless) {
+        const registry = new Map();
+        for (const [name, dep] of scope.dependencies) {
+            if (dep.kind === checker.MetaKind.Directive) {
+                registry.set(name, [dep, ...hostDirectivesResolver.resolve(dep)]);
+            }
+        }
+        return new checker.SelectorlessMatcher(registry);
+    }
     const matcher = new checker.SelectorMatcher();
+    const dependencies = scope.kind === checker.ComponentScopeKind.NgModule
+        ? scope.compilation.dependencies
+        : scope.dependencies;
     for (const dep of dependencies) {
         if (dep.kind === checker.MetaKind.Directive && dep.selector !== null) {
             matcher.addSelectables(checker.CssSelector.parse(dep.selector), [dep]);
         }
     }
-    // TODO(crisbeto): implement for selectorless.
-    return new checker.R3TargetBinder(matcher);
-}
-/**
- * Returns the list of dependencies from `@Component.deferredImports` if provided.
- */
-function getExplicitlyDeferredDeps(scope) {
-    return scope.kind === checker.ComponentScopeKind.NgModule
-        ? []
-        : scope.deferredDependencies;
-}
-function extractPipes(dependencies) {
-    const pipes = new Map();
-    for (const dep of dependencies) {
-        if (dep.kind === checker.MetaKind.Pipe) {
-            pipes.set(dep.name, dep);
-        }
-    }
-    return pipes;
+    return matcher;
 }
 /**
  * Drop references to existing imports for deferrable symbols that should be present
@@ -10816,41 +11395,49 @@ class PipeDecoratorHandler {
         if (decorator.args === null) {
             throw new checker.FatalDiagnosticError(checker.ErrorCode.DECORATOR_NOT_CALLED, decorator.node, `@Pipe must be called`);
         }
-        if (decorator.args.length !== 1) {
-            throw new checker.FatalDiagnosticError(checker.ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, '@Pipe must have exactly one argument');
-        }
-        const meta = checker.unwrapExpression(decorator.args[0]);
-        if (!ts.isObjectLiteralExpression(meta)) {
-            throw new checker.FatalDiagnosticError(checker.ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, '@Pipe must have a literal argument');
-        }
-        const pipe = checker.reflectObjectLiteral(meta);
-        if (!pipe.has('name')) {
-            throw new checker.FatalDiagnosticError(checker.ErrorCode.PIPE_MISSING_NAME, meta, `@Pipe decorator is missing name field`);
-        }
-        const pipeNameExpr = pipe.get('name');
-        const pipeName = this.evaluator.evaluate(pipeNameExpr);
-        if (typeof pipeName !== 'string') {
-            throw checker.createValueHasWrongTypeError(pipeNameExpr, pipeName, `@Pipe.name must be a string`);
-        }
+        const meta = decorator.args.length === 0 ||
+            // TODO(crisbeto): temporary for testing until we've changed
+            // the pipe public API not to require a name.
+            (ts.isNonNullExpression(decorator.args[0]) &&
+                decorator.args[0].expression.kind === ts.SyntaxKind.NullKeyword)
+            ? null
+            : checker.unwrapExpression(decorator.args[0]);
+        let pipeName = null;
+        let pipeNameExpr = null;
         let pure = true;
-        if (pipe.has('pure')) {
-            const expr = pipe.get('pure');
-            const pureValue = this.evaluator.evaluate(expr);
-            if (typeof pureValue !== 'boolean') {
-                throw checker.createValueHasWrongTypeError(expr, pureValue, `@Pipe.pure must be a boolean`);
-            }
-            pure = pureValue;
-        }
         let isStandalone = this.implicitStandaloneValue;
-        if (pipe.has('standalone')) {
-            const expr = pipe.get('standalone');
-            const resolved = this.evaluator.evaluate(expr);
-            if (typeof resolved !== 'boolean') {
-                throw checker.createValueHasWrongTypeError(expr, resolved, `standalone flag must be a boolean`);
+        if (meta !== null) {
+            if (!ts.isObjectLiteralExpression(meta)) {
+                throw new checker.FatalDiagnosticError(checker.ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, '@Pipe must have a literal argument');
+            }
+            const pipe = checker.reflectObjectLiteral(meta);
+            if (!pipe.has('name')) {
+                throw new checker.FatalDiagnosticError(checker.ErrorCode.PIPE_MISSING_NAME, meta, `@Pipe decorator is missing name field`);
+            }
+            pipeNameExpr = pipe.get('name');
+            const evaluatedName = this.evaluator.evaluate(pipeNameExpr);
+            if (typeof evaluatedName !== 'string') {
+                throw checker.createValueHasWrongTypeError(pipeNameExpr, evaluatedName, `@Pipe.name must be a string`);
+            }
+            pipeName = evaluatedName;
+            if (pipe.has('pure')) {
+                const expr = pipe.get('pure');
+                const pureValue = this.evaluator.evaluate(expr);
+                if (typeof pureValue !== 'boolean') {
+                    throw checker.createValueHasWrongTypeError(expr, pureValue, `@Pipe.pure must be a boolean`);
+                }
+                pure = pureValue;
             }
-            isStandalone = resolved;
-            if (!isStandalone && this.strictStandalone) {
-                throw new checker.FatalDiagnosticError(checker.ErrorCode.NON_STANDALONE_NOT_ALLOWED, expr, `Only standalone pipes are allowed when 'strictStandalone' is enabled.`);
+            if (pipe.has('standalone')) {
+                const expr = pipe.get('standalone');
+                const resolved = this.evaluator.evaluate(expr);
+                if (typeof resolved !== 'boolean') {
+                    throw checker.createValueHasWrongTypeError(expr, resolved, `standalone flag must be a boolean`);
+                }
+                isStandalone = resolved;
+                if (!isStandalone && this.strictStandalone) {
+                    throw new checker.FatalDiagnosticError(checker.ErrorCode.NON_STANDALONE_NOT_ALLOWED, expr, `Only standalone pipes are allowed when 'strictStandalone' is enabled.`);
+                }
             }
         }
         return {
@@ -10873,7 +11460,7 @@ class PipeDecoratorHandler {
         };
     }
     symbol(node, analysis) {
-        return new PipeSymbol(node, analysis.meta.pipeName);
+        return new PipeSymbol(node, analysis.meta.pipeName ?? analysis.meta.name);
     }
     register(node, analysis) {
         const ref = new checker.Reference(node);
@@ -10935,7 +11522,7 @@ class PipeDecoratorHandler {
  * @description
  * Entry point for all public APIs of the compiler-cli package.
  */
-new checker.Version('20.0.6');
+new checker.Version('20.1.0-next.1');
 
 /**
  * Whether a given decorator should be treated as an Angular decorator.
@@ -14000,6 +14587,8 @@ var IdentifierKind;
     IdentifierKind[IdentifierKind["Reference"] = 5] = "Reference";
     IdentifierKind[IdentifierKind["Variable"] = 6] = "Variable";
     IdentifierKind[IdentifierKind["LetDeclaration"] = 7] = "LetDeclaration";
+    IdentifierKind[IdentifierKind["Component"] = 8] = "Component";
+    IdentifierKind[IdentifierKind["Directive"] = 9] = "Directive";
 })(IdentifierKind || (IdentifierKind = {}));
 /**
  * Describes the absolute byte offsets of a text anchor in a source code.
@@ -14029,109 +14618,20 @@ class IndexingContext {
     }
 }
 
-/**
- * Visits the AST of an Angular template syntax expression, finding interesting
- * entities (variable references, etc.). Creates an array of Entities found in
- * the expression, with the location of the Entities being relative to the
- * expression.
- *
- * Visiting `text {{prop}}` will return
- * `[TopLevelIdentifier {name: 'prop', span: {start: 7, end: 11}}]`.
- */
-class ExpressionVisitor extends checker.RecursiveAstVisitor {
-    expressionStr;
-    absoluteOffset;
-    boundTemplate;
-    targetToIdentifier;
-    identifiers = [];
-    errors = [];
-    constructor(expressionStr, absoluteOffset, boundTemplate, targetToIdentifier) {
-        super();
-        this.expressionStr = expressionStr;
-        this.absoluteOffset = absoluteOffset;
-        this.boundTemplate = boundTemplate;
-        this.targetToIdentifier = targetToIdentifier;
-    }
-    /**
-     * Returns identifiers discovered in an expression.
-     *
-     * @param ast expression AST to visit
-     * @param source expression AST source code
-     * @param absoluteOffset absolute byte offset from start of the file to the start of the AST
-     * source code.
-     * @param boundTemplate bound target of the entire template, which can be used to query for the
-     * entities expressions target.
-     * @param targetToIdentifier closure converting a template target node to its identifier.
-     */
-    static getIdentifiers(ast, source, absoluteOffset, boundTemplate, targetToIdentifier) {
-        const visitor = new ExpressionVisitor(source, absoluteOffset, boundTemplate, targetToIdentifier);
-        visitor.visit(ast);
-        return { identifiers: visitor.identifiers, errors: visitor.errors };
-    }
-    visit(ast) {
-        ast.visit(this);
-    }
-    visitPropertyRead(ast, context) {
-        this.visitIdentifier(ast, IdentifierKind.Property);
-        super.visitPropertyRead(ast, context);
-    }
-    visitPropertyWrite(ast, context) {
-        this.visitIdentifier(ast, IdentifierKind.Property);
-        super.visitPropertyWrite(ast, context);
-    }
-    /**
-     * Visits an identifier, adding it to the identifier store if it is useful for indexing.
-     *
-     * @param ast expression AST the identifier is in
-     * @param kind identifier kind
-     */
-    visitIdentifier(ast, kind) {
-        // The definition of a non-top-level property such as `bar` in `{{foo.bar}}` is currently
-        // impossible to determine by an indexer and unsupported by the indexing module.
-        // The indexing module also does not currently support references to identifiers declared in the
-        // template itself, which have a non-null expression target.
-        if (!(ast.receiver instanceof checker.ImplicitReceiver)) {
-            return;
-        }
-        // The source span of the requested AST starts at a location that is offset from the expression.
-        let identifierStart = ast.sourceSpan.start - this.absoluteOffset;
-        if (ast instanceof checker.PropertyRead || ast instanceof checker.PropertyWrite) {
-            // For `PropertyRead` and `PropertyWrite`, the identifier starts at the `nameSpan`, not
-            // necessarily the `sourceSpan`.
-            identifierStart = ast.nameSpan.start - this.absoluteOffset;
-        }
-        if (!this.expressionStr.substring(identifierStart).startsWith(ast.name)) {
-            this.errors.push(new Error(`Impossible state: "${ast.name}" not found in "${this.expressionStr}" at location ${identifierStart}`));
-            return;
-        }
-        // Join the relative position of the expression within a node with the absolute position
-        // of the node to get the absolute position of the expression in the source code.
-        const absoluteStart = this.absoluteOffset + identifierStart;
-        const span = new AbsoluteSourceSpan(absoluteStart, absoluteStart + ast.name.length);
-        const targetAst = this.boundTemplate.getExpressionTarget(ast);
-        const target = targetAst ? this.targetToIdentifier(targetAst) : null;
-        const identifier = {
-            name: ast.name,
-            span,
-            kind,
-            target,
-        };
-        this.identifiers.push(identifier);
-    }
-}
 /**
  * Visits the AST of a parsed Angular template. Discovers and stores
  * identifiers of interest, deferring to an `ExpressionVisitor` as needed.
  */
-let TemplateVisitor$1 = class TemplateVisitor extends checker.RecursiveVisitor {
+let TemplateVisitor$1 = class TemplateVisitor extends checker.CombinedRecursiveAstVisitor {
     boundTemplate;
     // Identifiers of interest found in the template.
     identifiers = new Set();
     errors = [];
+    currentAstWithSource = null;
     // Map of targets in a template to their identifiers.
     targetIdentifierCache = new Map();
     // Map of elements and templates to their identifiers.
-    elementAndTemplateIdentifierCache = new Map();
+    directiveHostIdentifierCache = new Map();
     /**
      * Creates a template visitor for a bound template target. The bound target can be used when
      * deferred to the expression visitor to get information about the target of an expression.
@@ -14142,139 +14642,78 @@ let TemplateVisitor$1 = class TemplateVisitor extends checker.RecursiveVisitor {
         super();
         this.boundTemplate = boundTemplate;
     }
-    /**
-     * Visits a node in the template.
-     *
-     * @param node node to visit
-     */
-    visit(node) {
-        node.visit(this);
-    }
-    visitAll(nodes) {
-        nodes.forEach((node) => this.visit(node));
-    }
     /**
      * Add an identifier for an HTML element and visit its children recursively.
      *
      * @param element
      */
     visitElement(element) {
-        const elementIdentifier = this.elementOrTemplateToIdentifier(element);
+        const elementIdentifier = this.directiveHostToIdentifier(element);
         if (elementIdentifier !== null) {
             this.identifiers.add(elementIdentifier);
         }
-        this.visitAll(element.references);
-        this.visitAll(element.inputs);
-        this.visitAll(element.attributes);
-        this.visitAll(element.directives);
-        this.visitAll(element.children);
-        this.visitAll(element.outputs);
+        super.visitElement(element);
     }
     visitTemplate(template) {
-        const templateIdentifier = this.elementOrTemplateToIdentifier(template);
+        const templateIdentifier = this.directiveHostToIdentifier(template);
         if (templateIdentifier !== null) {
             this.identifiers.add(templateIdentifier);
         }
-        this.visitAll(template.directives);
-        this.visitAll(template.variables);
-        this.visitAll(template.attributes);
-        this.visitAll(template.templateAttrs);
-        this.visitAll(template.children);
-        this.visitAll(template.references);
-    }
-    visitBoundAttribute(attribute) {
-        // If the bound attribute has no value, it cannot have any identifiers in the value expression.
-        if (attribute.valueSpan === undefined) {
-            return;
-        }
-        const { identifiers, errors } = ExpressionVisitor.getIdentifiers(attribute.value, attribute.valueSpan.toString(), attribute.valueSpan.start.offset, this.boundTemplate, this.targetToIdentifier.bind(this));
-        identifiers.forEach((id) => this.identifiers.add(id));
-        this.errors.push(...errors);
-    }
-    visitBoundEvent(attribute) {
-        this.visitExpression(attribute.handler);
-    }
-    visitBoundText(text) {
-        this.visitExpression(text.value);
+        super.visitTemplate(template);
     }
     visitReference(reference) {
         const referenceIdentifier = this.targetToIdentifier(reference);
-        if (referenceIdentifier === null) {
-            return;
+        if (referenceIdentifier !== null) {
+            this.identifiers.add(referenceIdentifier);
         }
-        this.identifiers.add(referenceIdentifier);
+        super.visitReference(reference);
     }
     visitVariable(variable) {
         const variableIdentifier = this.targetToIdentifier(variable);
-        if (variableIdentifier === null) {
-            return;
-        }
-        this.identifiers.add(variableIdentifier);
-    }
-    visitDeferredBlock(deferred) {
-        deferred.visitAll(this);
-    }
-    visitDeferredBlockPlaceholder(block) {
-        this.visitAll(block.children);
-    }
-    visitDeferredBlockError(block) {
-        this.visitAll(block.children);
-    }
-    visitDeferredBlockLoading(block) {
-        this.visitAll(block.children);
-    }
-    visitDeferredTrigger(trigger) {
-        if (trigger instanceof checker.BoundDeferredTrigger) {
-            this.visitExpression(trigger.value);
+        if (variableIdentifier !== null) {
+            this.identifiers.add(variableIdentifier);
         }
-    }
-    visitSwitchBlock(block) {
-        this.visitExpression(block.expression);
-        this.visitAll(block.cases);
-    }
-    visitSwitchBlockCase(block) {
-        block.expression && this.visitExpression(block.expression);
-        this.visitAll(block.children);
-    }
-    visitForLoopBlock(block) {
-        block.item.visit(this);
-        this.visitAll(block.contextVariables);
-        this.visitExpression(block.expression);
-        this.visitAll(block.children);
-        block.empty?.visit(this);
-    }
-    visitForLoopBlockEmpty(block) {
-        this.visitAll(block.children);
-    }
-    visitIfBlock(block) {
-        this.visitAll(block.branches);
-    }
-    visitIfBlockBranch(block) {
-        block.expression && this.visitExpression(block.expression);
-        block.expressionAlias?.visit(this);
-        this.visitAll(block.children);
+        super.visitVariable(variable);
     }
     visitLetDeclaration(decl) {
         const identifier = this.targetToIdentifier(decl);
         if (identifier !== null) {
             this.identifiers.add(identifier);
         }
-        this.visitExpression(decl.value);
+        super.visitLetDeclaration(decl);
     }
     visitComponent(component) {
-        throw new Error('TODO');
+        const identifier = this.directiveHostToIdentifier(component);
+        if (identifier !== null) {
+            this.identifiers.add(identifier);
+        }
+        super.visitComponent(component);
     }
     visitDirective(directive) {
-        throw new Error('TODO');
+        const identifier = this.directiveHostToIdentifier(directive);
+        if (identifier !== null) {
+            this.identifiers.add(identifier);
+        }
+        super.visitDirective(directive);
+    }
+    visitPropertyRead(ast) {
+        this.visitIdentifier(ast, IdentifierKind.Property);
+        super.visitPropertyRead(ast, null);
+    }
+    visitBoundAttribute(attribute) {
+        const previous = this.currentAstWithSource;
+        this.currentAstWithSource = {
+            source: attribute.valueSpan?.toString() || null,
+            absoluteOffset: attribute.valueSpan ? attribute.valueSpan.start.offset : -1,
+        };
+        this.visit(attribute.value instanceof checker.ASTWithSource ? attribute.value.ast : attribute.value);
+        this.currentAstWithSource = previous;
     }
     /** Creates an identifier for a template element or template node. */
-    elementOrTemplateToIdentifier(node) {
-        if (node instanceof checker.Component || node instanceof checker.Directive) {
-            throw new Error('TODO');
-        }
+    directiveHostToIdentifier(node) {
         // If this node has already been seen, return the cached result.
-        if (this.elementAndTemplateIdentifierCache.has(node)) {
-            return this.elementAndTemplateIdentifierCache.get(node);
+        if (this.directiveHostIdentifierCache.has(node)) {
+            return this.directiveHostIdentifierCache.get(node);
         }
         let name;
         let kind;
@@ -14282,14 +14721,23 @@ let TemplateVisitor$1 = class TemplateVisitor extends checker.RecursiveVisitor {
             name = node.tagName ?? 'ng-template';
             kind = IdentifierKind.Template;
         }
-        else {
+        else if (node instanceof checker.Element) {
             name = node.name;
             kind = IdentifierKind.Element;
         }
+        else if (node instanceof checker.Component) {
+            name = node.fullName;
+            kind = IdentifierKind.Component;
+        }
+        else {
+            name = node.name;
+            kind = IdentifierKind.Directive;
+        }
         // Namespaced elements have a particular format for `node.name` that needs to be handled.
         // For example, an `<svg>` element has a `node.name` of `':svg:svg'`.
         // TODO(alxhub): properly handle namespaced elements
-        if (name.startsWith(':')) {
+        if ((node instanceof checker.Template || node instanceof checker.Element) &&
+            name.startsWith(':')) {
             name = name.split(':').pop();
         }
         const sourceSpan = node.startSourceSpan;
@@ -14324,7 +14772,7 @@ let TemplateVisitor$1 = class TemplateVisitor extends checker.RecursiveVisitor {
             })),
             // cast b/c pre-TypeScript 3.5 unions aren't well discriminated
         };
-        this.elementAndTemplateIdentifierCache.set(node, identifier);
+        this.directiveHostIdentifierCache.set(node, identifier);
         return identifier;
     }
     /** Creates an identifier for a template reference or template variable target. */
@@ -14353,10 +14801,10 @@ let TemplateVisitor$1 = class TemplateVisitor extends checker.RecursiveVisitor {
                     refTarget instanceof checker.Template ||
                     refTarget instanceof checker.Component ||
                     refTarget instanceof checker.Directive) {
-                    node = this.elementOrTemplateToIdentifier(refTarget);
+                    node = this.directiveHostToIdentifier(refTarget);
                 }
                 else {
-                    node = this.elementOrTemplateToIdentifier(refTarget.node);
+                    node = this.directiveHostToIdentifier(refTarget.node);
                     directive = refTarget.directive.ref.node;
                 }
                 if (node === null) {
@@ -14406,16 +14854,60 @@ let TemplateVisitor$1 = class TemplateVisitor extends checker.RecursiveVisitor {
      *
      * @param node node whose expression to visit
      */
-    visitExpression(ast) {
-        // Only include ASTs that have information about their source and absolute source spans.
-        if (ast instanceof checker.ASTWithSource && ast.source !== null) {
-            // Make target to identifier mapping closure stateful to this visitor instance.
-            const targetToIdentifier = this.targetToIdentifier.bind(this);
-            const absoluteOffset = ast.sourceSpan.start;
-            const { identifiers, errors } = ExpressionVisitor.getIdentifiers(ast, ast.source, absoluteOffset, this.boundTemplate, targetToIdentifier);
-            identifiers.forEach((id) => this.identifiers.add(id));
-            this.errors.push(...errors);
+    visit(node) {
+        if (node instanceof checker.ASTWithSource) {
+            const previous = this.currentAstWithSource;
+            this.currentAstWithSource = { source: node.source, absoluteOffset: node.sourceSpan.start };
+            super.visit(node.ast);
+            this.currentAstWithSource = previous;
+        }
+        else {
+            super.visit(node);
+        }
+    }
+    /**
+     * Visits an identifier, adding it to the identifier store if it is useful for indexing.
+     *
+     * @param ast expression AST the identifier is in
+     * @param kind identifier kind
+     */
+    visitIdentifier(ast, kind) {
+        // Only handle identifiers in expressions that have a source location.
+        if (this.currentAstWithSource === null || this.currentAstWithSource.source === null) {
+            return;
+        }
+        // The definition of a non-top-level property such as `bar` in `{{foo.bar}}` is currently
+        // impossible to determine by an indexer and unsupported by the indexing module.
+        // The indexing module also does not currently support references to identifiers declared in the
+        // template itself, which have a non-null expression target.
+        if (!(ast.receiver instanceof checker.ImplicitReceiver)) {
+            return;
         }
+        const { absoluteOffset, source: expressionStr } = this.currentAstWithSource;
+        // The source span of the requested AST starts at a location that is offset from the expression.
+        let identifierStart = ast.sourceSpan.start - absoluteOffset;
+        if (ast instanceof checker.PropertyRead) {
+            // For `PropertyRead` and the identifier starts at the `nameSpan`,
+            // not necessarily the `sourceSpan`.
+            identifierStart = ast.nameSpan.start - absoluteOffset;
+        }
+        if (!expressionStr.substring(identifierStart).startsWith(ast.name)) {
+            this.errors.push(new Error(`Impossible state: "${ast.name}" not found in "${expressionStr}" at location ${identifierStart}`));
+            return;
+        }
+        // Join the relative position of the expression within a node with the absolute position
+        // of the node to get the absolute position of the expression in the source code.
+        const absoluteStart = absoluteOffset + identifierStart;
+        const span = new AbsoluteSourceSpan(absoluteStart, absoluteStart + ast.name.length);
+        const targetAst = this.boundTemplate.getExpressionTarget(ast);
+        const target = targetAst ? this.targetToIdentifier(targetAst) : null;
+        const identifier = {
+            name: ast.name,
+            span,
+            kind,
+            target,
+        };
+        this.identifiers.add(identifier);
     }
 };
 /**
@@ -14427,7 +14919,7 @@ let TemplateVisitor$1 = class TemplateVisitor extends checker.RecursiveVisitor {
 function getTemplateIdentifiers(boundTemplate) {
     const visitor = new TemplateVisitor$1(boundTemplate);
     if (boundTemplate.target.template !== undefined) {
-        visitor.visitAll(boundTemplate.target.template);
+        checker.visitAll(visitor, boundTemplate.target.template);
     }
     return { identifiers: visitor.identifiers, errors: visitor.errors };
 }
@@ -14839,7 +15331,10 @@ class StandaloneComponentScopeReader {
         if (!this.cache.has(clazz)) {
             const clazzRef = new checker.Reference(clazz);
             const clazzMeta = this.metaReader.getDirectiveMetadata(clazzRef);
-            if (clazzMeta === null || !clazzMeta.isComponent || !clazzMeta.isStandalone) {
+            if (clazzMeta === null ||
+                !clazzMeta.isComponent ||
+                !clazzMeta.isStandalone ||
+                clazzMeta.selectorlessEnabled) {
                 this.cache.set(clazz, null);
                 return null;
             }
@@ -14994,7 +15489,7 @@ class TemplateCheckWithVisitor {
 /**
  * Visits all nodes in a template (TmplAstNode and AST) and calls `visitNode` for each one.
  */
-class TemplateVisitor extends checker.RecursiveAstVisitor {
+class TemplateVisitor extends checker.CombinedRecursiveAstVisitor {
     ctx;
     component;
     check;
@@ -15005,133 +15500,33 @@ class TemplateVisitor extends checker.RecursiveAstVisitor {
         this.component = component;
         this.check = check;
     }
-    visit(node, context) {
+    visit(node) {
         this.diagnostics.push(...this.check.visitNode(this.ctx, this.component, node));
-        node.visit(this);
-    }
-    visitAllNodes(nodes) {
-        for (const node of nodes) {
-            this.visit(node);
-        }
-    }
-    visitAst(ast) {
-        if (ast instanceof checker.ASTWithSource) {
-            ast = ast.ast;
-        }
-        this.visit(ast);
-    }
-    visitElement(element) {
-        this.visitAllNodes(element.attributes);
-        this.visitAllNodes(element.inputs);
-        this.visitAllNodes(element.outputs);
-        this.visitAllNodes(element.directives);
-        this.visitAllNodes(element.references);
-        this.visitAllNodes(element.children);
+        super.visit(node);
     }
     visitTemplate(template) {
         const isInlineTemplate = template.tagName === 'ng-template';
-        this.visitAllNodes(template.attributes);
+        this.visitAllTemplateNodes(template.attributes);
         if (isInlineTemplate) {
             // Only visit input/outputs if this isn't an inline template node generated for a structural
             // directive (like `<div *ngIf></div>`). These nodes would be visited when the underlying
             // element of an inline template node is processed.
-            this.visitAllNodes(template.inputs);
-            this.visitAllNodes(template.outputs);
+            this.visitAllTemplateNodes(template.inputs);
+            this.visitAllTemplateNodes(template.outputs);
         }
-        this.visitAllNodes(template.directives);
+        this.visitAllTemplateNodes(template.directives);
         // TODO(crisbeto): remove this condition when deleting `canVisitStructuralAttributes`.
         if (this.check.canVisitStructuralAttributes || isInlineTemplate) {
             // `templateAttrs` aren't transferred over to the inner element so we always have to visit them.
-            this.visitAllNodes(template.templateAttrs);
-        }
-        this.visitAllNodes(template.variables);
-        this.visitAllNodes(template.references);
-        this.visitAllNodes(template.children);
-    }
-    visitContent(content) {
-        this.visitAllNodes(content.children);
-    }
-    visitVariable(variable) { }
-    visitReference(reference) { }
-    visitTextAttribute(attribute) { }
-    visitUnknownBlock(block) { }
-    visitBoundAttribute(attribute) {
-        this.visitAst(attribute.value);
-    }
-    visitBoundEvent(attribute) {
-        this.visitAst(attribute.handler);
-    }
-    visitText(text) { }
-    visitBoundText(text) {
-        this.visitAst(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 checker.BoundDeferredTrigger) {
-            this.visitAst(trigger.value);
+            this.visitAllTemplateNodes(template.templateAttrs);
         }
-    }
-    visitDeferredBlockPlaceholder(block) {
-        this.visitAllNodes(block.children);
-    }
-    visitDeferredBlockError(block) {
-        this.visitAllNodes(block.children);
-    }
-    visitDeferredBlockLoading(block) {
-        this.visitAllNodes(block.children);
-    }
-    visitSwitchBlock(block) {
-        this.visitAst(block.expression);
-        this.visitAllNodes(block.cases);
-    }
-    visitSwitchBlockCase(block) {
-        block.expression && this.visitAst(block.expression);
-        this.visitAllNodes(block.children);
-    }
-    visitForLoopBlock(block) {
-        block.item.visit(this);
-        this.visitAllNodes(block.contextVariables);
-        this.visitAst(block.expression);
-        this.visitAllNodes(block.children);
-        block.empty?.visit(this);
-    }
-    visitForLoopBlockEmpty(block) {
-        this.visitAllNodes(block.children);
-    }
-    visitIfBlock(block) {
-        this.visitAllNodes(block.branches);
-    }
-    visitIfBlockBranch(block) {
-        block.expression && this.visitAst(block.expression);
-        block.expressionAlias?.visit(this);
-        this.visitAllNodes(block.children);
-    }
-    visitLetDeclaration(decl) {
-        this.visitAst(decl.value);
-    }
-    visitComponent(component) {
-        this.visitAllNodes(component.attributes);
-        this.visitAllNodes(component.inputs);
-        this.visitAllNodes(component.outputs);
-        this.visitAllNodes(component.directives);
-        this.visitAllNodes(component.references);
-        this.visitAllNodes(component.children);
-    }
-    visitDirective(directive) {
-        this.visitAllNodes(directive.attributes);
-        this.visitAllNodes(directive.inputs);
-        this.visitAllNodes(directive.outputs);
-        this.visitAllNodes(directive.references);
+        this.visitAllTemplateNodes(template.variables);
+        this.visitAllTemplateNodes(template.references);
+        this.visitAllTemplateNodes(template.children);
     }
     getDiagnostics(template) {
         this.diagnostics = [];
-        this.visitAllNodes(template);
+        this.visitAllTemplateNodes(template);
         return this.diagnostics;
     }
 }
@@ -15152,6 +15547,7 @@ class InterpolatedSignalCheck extends TemplateCheckWithVisitor {
         // interpolations like `{{ mySignal }}`
         if (node instanceof checker.Interpolation) {
             return node.expressions
+                .map((item) => (item instanceof checker.PrefixNot ? item.expression : item))
                 .filter((item) => item instanceof checker.PropertyRead)
                 .flatMap((item) => buildDiagnosticForSignal(ctx, item, component));
         }
@@ -15164,6 +15560,7 @@ class InterpolatedSignalCheck extends TemplateCheckWithVisitor {
                 return [];
             }
             // otherwise, we check if the node is
+            const nodeAst = isPropertyReadNodeAst(node);
             if (
             // a bound property like `[prop]="mySignal"`
             (node.type === checker.BindingType.Property ||
@@ -15175,14 +15572,25 @@ class InterpolatedSignalCheck extends TemplateCheckWithVisitor {
                 node.type === checker.BindingType.Attribute ||
                 // or an animation binding like `[@myAnimation]="mySignal"`
                 node.type === checker.BindingType.Animation) &&
-                node.value instanceof checker.ASTWithSource &&
-                node.value.ast instanceof checker.PropertyRead) {
-                return buildDiagnosticForSignal(ctx, node.value.ast, component);
+                nodeAst) {
+                return buildDiagnosticForSignal(ctx, nodeAst, component);
             }
         }
         return [];
     }
 }
+function isPropertyReadNodeAst(node) {
+    if (node.value instanceof checker.ASTWithSource === false) {
+        return undefined;
+    }
+    if (node.value.ast instanceof checker.PrefixNot && node.value.ast.expression instanceof checker.PropertyRead) {
+        return node.value.ast.expression;
+    }
+    if (node.value.ast instanceof checker.PropertyRead) {
+        return node.value.ast;
+    }
+    return undefined;
+}
 function isFunctionInstanceProperty(name) {
     return FUNCTION_INSTANCE_PROPERTIES.has(name);
 }
@@ -15932,9 +16340,13 @@ class ExpressionsSemanticsVisitor extends checker.RecursiveAstVisitor {
         this.component = component;
         this.diagnostics = diagnostics;
     }
-    visitPropertyWrite(ast, context) {
-        super.visitPropertyWrite(ast, context);
-        this.checkForIllegalWriteInEventBinding(ast, context);
+    visitBinary(ast, context) {
+        if (ast.operation === '=' && ast.left instanceof checker.PropertyRead) {
+            this.checkForIllegalWriteInEventBinding(ast.left, context);
+        }
+        else {
+            super.visitBinary(ast, context);
+        }
     }
     visitPropertyRead(ast, context) {
         super.visitPropertyRead(ast, context);
@@ -16146,6 +16558,7 @@ class UnusedStandaloneImportsRule {
             const pipeMeta = this.templateTypeChecker.getPipeMetadata(currentNode);
             if (pipeMeta !== null &&
                 pipeMeta.isStandalone &&
+                pipeMeta.name !== null &&
                 !usedPipes.has(pipeMeta.name) &&
                 !this.isPotentialSharedReference(current, rawImports)) {
                 unused ??= [];
@@ -18974,7 +19387,7 @@ var semver = /*@__PURE__*/getDefaultExportFromCjs(semverExports);
  * @param minVersion Minimum required version for the feature.
  */
 function coreVersionSupportsFeature(coreVersion, minVersion) {
-    // A version of `20.0.6` usually means that core is at head so it supports
+    // A version of `20.1.0-next.1` usually means that core is at head so it supports
     // all features. Use string interpolation prevent the placeholder from being replaced
     // with the current version during build time.
     if (coreVersion === `0.0.0-${'PLACEHOLDER'}`) {
@@ -19090,6 +19503,7 @@ class NgCompiler {
     enableHmr;
     implicitStandaloneValue;
     enableSelectorless;
+    emitDeclarationOnly;
     /**
      * `NgCompiler` can be reused for multiple compilations (for resource-only changes), and each
      * new compilation uses a fresh `PerfRecorder`. Thus, classes created with a lifespan of the
@@ -19135,6 +19549,8 @@ class NgCompiler {
         this.enableBlockSyntax = options['_enableBlockSyntax'] ?? true;
         this.enableLetSyntax = options['_enableLetSyntax'] ?? true;
         this.enableSelectorless = options['_enableSelectorless'] ?? false;
+        this.emitDeclarationOnly =
+            !!options.emitDeclarationOnly && !!options._experimentalAllowEmitDeclarationOnly;
         // Standalone by default is enabled since v19. We need to toggle it here,
         // because the language service extension may be running with the latest
         // version of the compiler against an older version of Angular.
@@ -19421,7 +19837,7 @@ class NgCompiler {
         }
         const defaultImportTracker = new checker.DefaultImportTracker();
         const before = [
-            ivyTransformFactory(compilation.traitCompiler, compilation.reflector, importRewriter, defaultImportTracker, compilation.localCompilationExtraImportsTracker, this.delegatingPerfRecorder, compilation.isCore, this.closureCompilerEnabled),
+            ivyTransformFactory(compilation.traitCompiler, compilation.reflector, importRewriter, defaultImportTracker, compilation.localCompilationExtraImportsTracker, this.delegatingPerfRecorder, compilation.isCore, this.closureCompilerEnabled, this.emitDeclarationOnly),
             aliasTransformFactory(compilation.traitCompiler.exportStatements),
             defaultImportTracker.importPreservingTransformer(),
         ];
@@ -19447,11 +19863,19 @@ class NgCompiler {
                 };
             });
         }
+        // Typescript transformer to add debugName metadata to signal functions.
+        before.push(signalMetadataTransform(this.inputProgram));
         const afterDeclarations = [];
         // In local compilation mode we don't make use of .d.ts files for Angular compilation, so their
         // transformation can be ditched.
-        if (this.options.compilationMode !== 'experimental-local' &&
+        if ((this.options.compilationMode !== 'experimental-local' || this.emitDeclarationOnly) &&
             compilation.dtsTransforms !== null) {
+            // If we are emitting declarations only, the script transformations are skipped by the TS
+            // compiler, so we have to add them to the afterDeclarations transforms to run their analysis
+            // because the declaration transform depends on their metadata output.
+            if (this.emitDeclarationOnly) {
+                afterDeclarations.push(...before);
+            }
             afterDeclarations.push(declarationTransformFactory(compilation.dtsTransforms, compilation.reflector, compilation.refEmitter, importRewriter));
         }
         // Only add aliasing re-exports to the .d.ts output if the `AliasingHost` requests it.
@@ -19789,6 +20213,9 @@ class NgCompiler {
                     break;
             }
         }
+        if (this.emitDeclarationOnly) {
+            compilationMode = checker.CompilationMode.LOCAL;
+        }
         const checker$1 = this.inputProgram.getTypeChecker();
         const reflector = new checker.TypeScriptReflectionHost(checker$1, compilationMode === checker.CompilationMode.LOCAL);
         // Construct the ReferenceEmitter.
@@ -19856,8 +20283,10 @@ class NgCompiler {
         const ngModuleIndex = new NgModuleIndexImpl(metaReader, localMetaReader);
         const ngModuleScopeRegistry = new LocalModuleScopeRegistry(localMetaReader, metaReader, depScopeReader, refEmitter, aliasingHost);
         const standaloneScopeReader = new StandaloneComponentScopeReader(metaReader, ngModuleScopeRegistry, depScopeReader);
+        const selectorlessScopeReader = new SelectorlessComponentScopeReader(metaReader, reflector);
         const scopeReader = new CompoundComponentScopeReader([
             ngModuleScopeRegistry,
+            selectorlessScopeReader,
             standaloneScopeReader,
         ]);
         const semanticDepGraphUpdater = this.incrementalCompilation.semanticDepGraphUpdater;
@@ -19915,17 +20344,17 @@ class NgCompiler {
         const jitDeclarationRegistry = new JitDeclarationRegistry();
         // Set up the IvyCompilation, which manages state for the Ivy transformer.
         const handlers = [
-            new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, this.adapter, ngModuleScopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs === true, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, this.incrementalCompilation.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, hostDirectivesResolver, importTracker, supportTestBed, compilationMode, deferredSymbolsTracker, !!this.options.forbidOrphanComponents, this.enableBlockSyntax, this.enableLetSyntax, externalRuntimeStyles, localCompilationExtraImportsTracker, jitDeclarationRegistry, this.options.i18nPreserveWhitespaceForLegacyExtraction ?? true, !!this.options.strictStandalone, this.enableHmr, this.implicitStandaloneValue, typeCheckHostBindings, this.enableSelectorless),
+            new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, this.adapter, ngModuleScopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs === true, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, this.incrementalCompilation.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, hostDirectivesResolver, importTracker, supportTestBed, compilationMode, deferredSymbolsTracker, !!this.options.forbidOrphanComponents, this.enableBlockSyntax, this.enableLetSyntax, externalRuntimeStyles, localCompilationExtraImportsTracker, jitDeclarationRegistry, this.options.i18nPreserveWhitespaceForLegacyExtraction ?? true, !!this.options.strictStandalone, this.enableHmr, this.implicitStandaloneValue, typeCheckHostBindings, this.enableSelectorless, this.emitDeclarationOnly),
             // TODO(alxhub): understand why the cast here is necessary (something to do with `null`
             // not being assignable to `unknown` when wrapped in `Readonly`).
-            new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, ngModuleScopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, importTracker, supportTestBed, typeCheckScopeRegistry, compilationMode, jitDeclarationRegistry, resourceRegistry, !!this.options.strictStandalone, this.implicitStandaloneValue, this.usePoisonedData, typeCheckHostBindings),
+            new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, ngModuleScopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, importTracker, supportTestBed, typeCheckScopeRegistry, compilationMode, jitDeclarationRegistry, resourceRegistry, !!this.options.strictStandalone, this.implicitStandaloneValue, this.usePoisonedData, typeCheckHostBindings, this.emitDeclarationOnly),
             // Pipe handler must be before injectable handler in list so pipe factories are printed
             // before injectable factories (so injectable factories can delegate to them)
             new PipeDecoratorHandler(reflector, evaluator, metaRegistry, ngModuleScopeRegistry, injectableRegistry, isCore, this.delegatingPerfRecorder, supportTestBed, compilationMode, !!this.options.generateExtraImportsInLocalMode, !!this.options.strictStandalone, this.implicitStandaloneValue),
             new InjectableDecoratorHandler(reflector, evaluator, isCore, strictCtorDeps, injectableRegistry, this.delegatingPerfRecorder, supportTestBed, compilationMode),
-            new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, ngModuleScopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, this.closureCompilerEnabled, this.options.onlyPublishPublicTypingsForNgModules ?? false, injectableRegistry, this.delegatingPerfRecorder, supportTestBed, supportJitMode, compilationMode, localCompilationExtraImportsTracker, jitDeclarationRegistry),
+            new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, ngModuleScopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, this.closureCompilerEnabled, this.options.onlyPublishPublicTypingsForNgModules ?? false, injectableRegistry, this.delegatingPerfRecorder, supportTestBed, supportJitMode, compilationMode, localCompilationExtraImportsTracker, jitDeclarationRegistry, this.emitDeclarationOnly),
         ];
-        const traitCompiler = new TraitCompiler(handlers, reflector, this.delegatingPerfRecorder, this.incrementalCompilation, this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms, semanticDepGraphUpdater, this.adapter);
+        const traitCompiler = new TraitCompiler(handlers, reflector, this.delegatingPerfRecorder, this.incrementalCompilation, this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms, semanticDepGraphUpdater, this.adapter, this.emitDeclarationOnly);
         // Template type-checking may use the `ProgramDriver` to produce new `ts.Program`(s). If this
         // happens, they need to be tracked by the `NgCompiler`.
         const notifyingDriver = new NotifyingProgramDriverWrapper(this.programDriver, (program) => {