@angular/core 19.0.0-next.9 → 19.0.0-rc.1

package/schematics/bundles/{program-6534a30a.js → program-71beec0b.js}

@@ -1,12 +1,12 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.9
+ * @license Angular v19.0.0-rc.1
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-var checker = require('./checker-3b2ea20f.js');
+var checker = require('./checker-9ca42e51.js');
 var ts = require('typescript');
 var p = require('path');
 require('os');
@@ -34,9 +34,31 @@ function _interopNamespace(e) {
 var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
 var p__namespace = /*#__PURE__*/_interopNamespace(p);
 
+class XmlTagDefinition {
+    closedByParent = false;
+    implicitNamespacePrefix = null;
+    isVoid = false;
+    ignoreFirstLf = false;
+    canSelfClose = true;
+    preventNamespaceInheritance = false;
+    requireExtraParent(currentParent) {
+        return false;
+    }
+    isClosedByChild(name) {
+        return false;
+    }
+    getContentType() {
+        return checker.TagContentType.PARSABLE_DATA;
+    }
+}
+const _TAG_DEFINITION = new XmlTagDefinition();
+function getXmlTagDefinition(tagName) {
+    return _TAG_DEFINITION;
+}
+
 class XmlParser extends checker.Parser {
     constructor() {
-        super(checker.getXmlTagDefinition);
+        super(getXmlTagDefinition);
     }
     parse(source, url, options = {}) {
         // Blocks and let declarations aren't supported in an XML context.
@@ -190,9 +212,11 @@ class _WriteVisitor$1 {
 // TODO(vicb): add error management (structure)
 // Extract messages as xml nodes from the xliff file
 class XliffParser {
-    constructor() {
-        this._locale = null;
-    }
+    // using non-null assertions because they're re(set) by parse()
+    _unitMlString;
+    _errors;
+    _msgIdToHtml;
+    _locale = null;
     parse(xliff, url) {
         this._unitMlString = null;
         this._msgIdToHtml = {};
@@ -268,6 +292,8 @@ class XliffParser {
 }
 // Convert ml nodes (xliff syntax) to i18n nodes
 class XmlToI18n$1 {
+    // using non-null assertion because it's re(set) by convert()
+    _errors;
     convert(message, url) {
         const xmlIcu = new XmlParser().parse(message, url, { tokenizeExpansionForms: true });
         this._errors = xmlIcu.errors;
@@ -399,13 +425,11 @@ class Xliff2 extends checker.Serializer {
         return { locale: locale, i18nNodesByMsgId };
     }
     digest(message) {
-        return checker.decimalDigest(message, /* preservePlaceholders */ true);
+        return checker.decimalDigest(message);
     }
 }
 class _WriteVisitor {
-    constructor() {
-        this._nextPlaceholderId = 0;
-    }
+    _nextPlaceholderId = 0;
     visitText(text, context) {
         return [new checker.Text$1(text.value)];
     }
@@ -498,9 +522,11 @@ class _WriteVisitor {
 }
 // Extract messages as xml nodes from the xliff file
 class Xliff2Parser {
-    constructor() {
-        this._locale = null;
-    }
+    // using non-null assertions because they're all (re)set by parse()
+    _unitMlString;
+    _errors;
+    _msgIdToHtml;
+    _locale = null;
     parse(xliff, url) {
         this._unitMlString = null;
         this._msgIdToHtml = {};
@@ -581,6 +607,8 @@ class Xliff2Parser {
 }
 // Convert ml nodes (xliff syntax) to i18n nodes
 class XmlToI18n {
+    // using non-null assertion because re(set) by convert()
+    _errors;
     convert(message, url) {
         const xmlIcu = new XmlParser().parse(message, url, { tokenizeExpansionForms: true });
         this._errors = xmlIcu.errors;
@@ -669,13 +697,18 @@ function getTypeForTag(tag) {
  * A container for message extracted from the templates.
  */
 class MessageBundle {
+    _htmlParser;
+    _implicitTags;
+    _implicitAttrs;
+    _locale;
+    _preserveWhitespace;
+    _messages = [];
     constructor(_htmlParser, _implicitTags, _implicitAttrs, _locale = null, _preserveWhitespace = true) {
         this._htmlParser = _htmlParser;
         this._implicitTags = _implicitTags;
         this._implicitAttrs = _implicitAttrs;
         this._locale = _locale;
         this._preserveWhitespace = _preserveWhitespace;
-        this._messages = [];
     }
     updateFromTemplate(source, url, interpolationConfig) {
         const htmlParserResult = this._htmlParser.parse(source, url, {
@@ -849,6 +882,96 @@ function compileClassDebugInfo(debugInfo) {
     return iife.callFn([]);
 }
 
+/*!
+ * @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
+ */
+/**
+ * Compiles the expression that initializes HMR for a class.
+ * @param meta HMR metadata extracted from the class.
+ */
+function compileHmrInitializer(meta) {
+    const id = encodeURIComponent(`${meta.filePath}@${meta.className}`);
+    const urlPartial = `/@ng/component?c=${id}&t=`;
+    const moduleName = 'm';
+    const dataName = 'd';
+    const timestampName = 't';
+    const importCallbackName = `${meta.className}_HmrLoad`;
+    const locals = meta.locals.map((localName) => checker.variable(localName));
+    // m.default
+    const defaultRead = checker.variable(moduleName).prop('default');
+    // ɵɵreplaceMetadata(Comp, m.default, [...]);
+    const replaceCall = checker.importExpr(checker.Identifiers.replaceMetadata)
+        .callFn([meta.type, defaultRead, new checker.ExternalExpr(checker.Identifiers.core), checker.literalArr(locals)]);
+    // (m) => m.default && ɵɵreplaceMetadata(...)
+    const replaceCallback = checker.arrowFn([new checker.FnParam(moduleName)], defaultRead.and(replaceCall));
+    // '<urlPartial>' + encodeURIComponent(t)
+    const urlValue = checker.literal(urlPartial)
+        .plus(checker.variable('encodeURIComponent').callFn([checker.variable(timestampName)]));
+    // function Cmp_HmrLoad(t) {
+    //   import(/* @vite-ignore */ url).then((m) => m.default && replaceMetadata(...));
+    // }
+    const importCallback = new checker.DeclareFunctionStmt(importCallbackName, [new checker.FnParam(timestampName)], [
+        // The vite-ignore special comment is required to prevent Vite from generating a superfluous
+        // warning for each usage within the development code. If Vite provides a method to
+        // programmatically avoid this warning in the future, this added comment can be removed here.
+        new checker.DynamicImportExpr(urlValue, null, '@vite-ignore')
+            .prop('then')
+            .callFn([replaceCallback])
+            .toStmt(),
+    ], null, checker.StmtModifier.Final);
+    // (d) => d.id === <id> && Cmp_HmrLoad(d.timestamp)
+    const updateCallback = checker.arrowFn([new checker.FnParam(dataName)], checker.variable(dataName)
+        .prop('id')
+        .identical(checker.literal(id))
+        .and(checker.variable(importCallbackName).callFn([checker.variable(dataName).prop('timestamp')])));
+    // Cmp_HmrLoad(Date.now());
+    // Initial call to kick off the loading in order to avoid edge cases with components
+    // coming from lazy chunks that change before the chunk has loaded.
+    const initialCall = checker.variable(importCallbackName)
+        .callFn([checker.variable('Date').prop('now').callFn([])]);
+    // import.meta.hot
+    const hotRead = checker.variable('import').prop('meta').prop('hot');
+    // import.meta.hot.on('angular:component-update', () => ...);
+    const hotListener = hotRead
+        .clone()
+        .prop('on')
+        .callFn([checker.literal('angular:component-update'), updateCallback]);
+    return checker.arrowFn([], [
+        // function Cmp_HmrLoad() {...}.
+        importCallback,
+        // ngDevMode && Cmp_HmrLoad(Date.now());
+        checker.devOnlyGuardedExpression(initialCall).toStmt(),
+        // ngDevMode && import.meta.hot && import.meta.hot.on(...)
+        checker.devOnlyGuardedExpression(hotRead.and(hotListener)).toStmt(),
+    ])
+        .callFn([]);
+}
+/**
+ * Compiles the HMR update callback for a class.
+ * @param definitions Compiled definitions for the class (e.g. `defineComponent` calls).
+ * @param constantStatements Supporting constants statements that were generated alongside
+ *  the definition.
+ * @param meta HMR metadata extracted from the class.
+ */
+function compileHmrUpdateCallback(definitions, constantStatements, meta) {
+    // The class name should always be first and core should be second.
+    const params = [meta.className, meta.coreName, ...meta.locals].map((name) => new checker.FnParam(name, checker.DYNAMIC_TYPE));
+    const body = [...constantStatements];
+    for (const field of definitions) {
+        if (field.initializer !== null) {
+            body.push(checker.variable(meta.className).prop(field.name).set(field.initializer).toStmt());
+            for (const stmt of field.statements) {
+                body.push(stmt);
+            }
+        }
+    }
+    return new checker.DeclareFunctionStmt(`${meta.className}_UpdateMetadata`, params, body, null, checker.StmtModifier.Final);
+}
+
 /**
  * Every time we make a breaking change to the declaration interface or partial-linker behavior, we
  * must update this constant to prevent old partial-linkers from incorrectly processing the
@@ -864,7 +987,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('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -882,7 +1005,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('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -977,10 +1100,10 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', checker.literal(minVersion));
-    definitionMap.set('version', checker.literal('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.1'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
-    if (meta.isStandalone) {
+    if (meta.isStandalone !== undefined) {
         definitionMap.set('isStandalone', checker.literal(meta.isStandalone));
     }
     if (meta.isSignal) {
@@ -1349,10 +1472,7 @@ function compileUsedDependenciesMetadata(meta) {
     });
 }
 class BlockPresenceVisitor extends checker.RecursiveVisitor$1 {
-    constructor() {
-        super(...arguments);
-        this.hasBlocks = false;
-    }
+    hasBlocks = false;
     visitDeferredBlock() {
         this.hasBlocks = true;
     }
@@ -1396,7 +1516,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('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -1431,7 +1551,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('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.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
@@ -1482,7 +1602,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('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -1515,7 +1635,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('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.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.
@@ -1566,11 +1686,11 @@ 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('19.0.0-next.9'));
+    definitionMap.set('version', checker.literal('19.0.0-rc.1'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
-    if (meta.isStandalone) {
+    if (meta.isStandalone !== undefined) {
         definitionMap.set('isStandalone', checker.literal(meta.isStandalone));
     }
     // e.g. `name: "myPipe"`
@@ -1601,14 +1721,15 @@ const CHARS_TO_ESCAPE = /[^a-zA-Z0-9/_]/g;
  * README.md for more details.
  */
 class UnifiedModulesAliasingHost {
+    unifiedModulesHost;
     constructor(unifiedModulesHost) {
         this.unifiedModulesHost = unifiedModulesHost;
-        /**
-         * With a `UnifiedModulesHost`, aliases are chosen automatically without the need to look through
-         * the exports present in a .d.ts file, so we can avoid cluttering the .d.ts files.
-         */
-        this.aliasExportsInDts = false;
     }
+    /**
+     * With a `UnifiedModulesHost`, aliases are chosen automatically without the need to look through
+     * the exports present in a .d.ts file, so we can avoid cluttering the .d.ts files.
+     */
+    aliasExportsInDts = false;
     maybeAliasSymbolAs(ref, context, ngModuleName, isReExport) {
         if (!isReExport) {
             // Aliasing is used with a UnifiedModulesHost to prevent transitive dependencies. Thus,
@@ -1654,16 +1775,17 @@ class UnifiedModulesAliasingHost {
  * more details.
  */
 class PrivateExportAliasingHost {
+    host;
     constructor(host) {
         this.host = host;
-        /**
-         * Under private export aliasing, the `AbsoluteModuleStrategy` used for emitting references will
-         * will select aliased exports that it finds in the .d.ts file for an NgModule's file. Thus,
-         * emitting these exports in .d.ts is a requirement for the `PrivateExportAliasingHost` to
-         * function correctly.
-         */
-        this.aliasExportsInDts = true;
     }
+    /**
+     * Under private export aliasing, the `AbsoluteModuleStrategy` used for emitting references will
+     * will select aliased exports that it finds in the .d.ts file for an NgModule's file. Thus,
+     * emitting these exports in .d.ts is a requirement for the `PrivateExportAliasingHost` to
+     * function correctly.
+     */
+    aliasExportsInDts = true;
     maybeAliasSymbolAs(ref, context, ngModuleName) {
         if (ref.hasOwningModuleGuess) {
             // Skip nodes that already have an associated absolute module specifier, since they can be
@@ -1731,6 +1853,27 @@ function normalizeSeparators(path) {
     // TODO: normalize path only for OS that need it.
     return path.replace(/\\/g, '/');
 }
+/**
+ * Attempts to generate a project-relative path
+ * @param sourceFile
+ * @param rootDirs
+ * @param compilerHost
+ * @returns
+ */
+function getProjectRelativePath(sourceFile, rootDirs, compilerHost) {
+    // Note: we need to pass both the file name and the root directories through getCanonicalFileName,
+    // because the root directories might've been passed through it already while the source files
+    // definitely have not. This can break the relative return value, because in some platforms
+    // getCanonicalFileName lowercases the path.
+    const filePath = compilerHost.getCanonicalFileName(sourceFile.fileName);
+    for (const rootDir of rootDirs) {
+        const rel = checker.relative(compilerHost.getCanonicalFileName(rootDir), filePath);
+        if (!rel.startsWith('..')) {
+            return rel;
+        }
+    }
+    return null;
+}
 
 /**
  * `ImportRewriter` that does no rewriting.
@@ -1742,6 +1885,9 @@ class NoopImportRewriter {
     rewriteSpecifier(specifier, inContextOfFile) {
         return specifier;
     }
+    rewriteNamespaceImportIdentifier(specifier) {
+        return specifier;
+    }
 }
 /**
  * A mapping of supported symbols that can be imported from within @angular/core, and the names by
@@ -1768,6 +1914,7 @@ const CORE_MODULE = '@angular/core';
  * file instead.
  */
 class R3SymbolsImportRewriter {
+    r3SymbolsPath;
     constructor(r3SymbolsPath) {
         this.r3SymbolsPath = r3SymbolsPath;
     }
@@ -1789,6 +1936,9 @@ class R3SymbolsImportRewriter {
         }
         return relativePathToR3Symbols;
     }
+    rewriteNamespaceImportIdentifier(specifier) {
+        return specifier;
+    }
 }
 function validateAndRewriteCoreSymbol(name) {
     if (!CORE_SUPPORTED_SYMBOLS.has(name)) {
@@ -1806,15 +1956,17 @@ const AssumeEager = 'AssumeEager';
  * in favor of using a dynamic import for cases when defer blocks are used.
  */
 class DeferredSymbolTracker {
+    typeChecker;
+    onlyExplicitDeferDependencyImports;
+    imports = new Map();
+    /**
+     * Map of a component class -> all import declarations that bring symbols
+     * used within `@Component.deferredImports` field.
+     */
+    explicitlyDeferredImports = new Map();
     constructor(typeChecker, onlyExplicitDeferDependencyImports) {
         this.typeChecker = typeChecker;
         this.onlyExplicitDeferDependencyImports = onlyExplicitDeferDependencyImports;
-        this.imports = new Map();
-        /**
-         * Map of a component class -> all import declarations that bring symbols
-         * used within `@Component.deferredImports` field.
-         */
-        this.explicitlyDeferredImports = new Map();
     }
     /**
      * Given an import declaration node, extract the names of all imported symbols
@@ -1993,10 +2145,8 @@ class DeferredSymbolTracker {
  * type checker may be necessary, depending on the context. Also does not track dynamic imports.
  */
 class ImportedSymbolsTracker {
-    constructor() {
-        this.fileToNamedImports = new WeakMap();
-        this.fileToNamespaceImports = new WeakMap();
-    }
+    fileToNamedImports = new WeakMap();
+    fileToNamespaceImports = new WeakMap();
     /**
      * Checks if an identifier is a potential reference to a specific named import within the same
      * file.
@@ -2112,12 +2262,13 @@ class ImportedSymbolsTracker {
  *
  */
 class LocalCompilationExtraImportsTracker {
+    typeChecker;
+    localImportsMap = new Map();
+    globalImportsSet = new Set();
+    /** Names of the files marked for extra import generation. */
+    markedFilesSet = new Set();
     constructor(typeChecker) {
         this.typeChecker = typeChecker;
-        this.localImportsMap = new Map();
-        this.globalImportsSet = new Set();
-        /** Names of the files marked for extra import generation. */
-        this.markedFilesSet = new Set();
     }
     /**
      * Marks the source file for extra imports generation.
@@ -2192,6 +2343,10 @@ function removeQuotations(s) {
  * definitions).
  */
 class ModuleResolver {
+    program;
+    compilerOptions;
+    host;
+    moduleResolutionCache;
     constructor(program, compilerOptions, host, moduleResolutionCache) {
         this.program = program;
         this.compilerOptions = compilerOptions;
@@ -2401,6 +2556,14 @@ function createUnsuitableInjectionTokenError(clazz, error) {
  * property name, or mapping from a specific class property to its binding property name.
  */
 class ClassPropertyMapping {
+    /**
+     * Mapping from class property names to the single `InputOrOutput` for that class property.
+     */
+    forwardMap;
+    /**
+     * Mapping from property names to one or more `InputOrOutput`s which share that name.
+     */
+    reverseMap;
     constructor(forwardMap) {
         this.forwardMap = forwardMap;
         this.reverseMap = reverseMapFromForwardMap(forwardMap);
@@ -2530,6 +2693,8 @@ function reverseMapFromForwardMap(forwardMap) {
  * from an upstream compilation already.
  */
 class DtsMetadataReader {
+    checker;
+    reflector;
     constructor(checker, reflector) {
         this.checker = checker;
         this.reflector = reflector;
@@ -2560,12 +2725,21 @@ class DtsMetadataReader {
         }
         // Read the ModuleData out of the type arguments.
         const [_, declarationMetadata, importMetadata, exportMetadata] = ngModuleDef.type.typeArguments;
+        const declarations = checker.extractReferencesFromType(this.checker, declarationMetadata, ref.bestGuessOwningModule);
+        const exports = checker.extractReferencesFromType(this.checker, exportMetadata, ref.bestGuessOwningModule);
+        const imports = checker.extractReferencesFromType(this.checker, importMetadata, ref.bestGuessOwningModule);
+        // The module is considered poisoned if it's exports couldn't be
+        // resolved completely. This would make the module not necessarily
+        // usable for scope computation relying on this module; so we propagate
+        // this "incompleteness" information to the caller.
+        const isPoisoned = exports.isIncomplete;
         return {
             kind: checker.MetaKind.NgModule,
             ref,
-            declarations: checker.extractReferencesFromType(this.checker, declarationMetadata, ref.bestGuessOwningModule),
-            exports: checker.extractReferencesFromType(this.checker, exportMetadata, ref.bestGuessOwningModule),
-            imports: checker.extractReferencesFromType(this.checker, importMetadata, ref.bestGuessOwningModule),
+            declarations: declarations.result,
+            isPoisoned,
+            exports: exports.result,
+            imports: imports.result,
             schemas: [],
             rawDeclarations: null,
             rawImports: null,
@@ -2608,6 +2782,8 @@ class DtsMetadataReader {
                     param.typeValueReference.importedName === 'TemplateRef');
             });
         const ngContentSelectors = def.type.typeArguments.length > 6 ? checker.readStringArrayType(def.type.typeArguments[6]) : null;
+        // Note: the default value is still `false` here, because only legacy .d.ts files written before
+        // we had so many arguments use this default.
         const isStandalone = def.type.typeArguments.length > 7 && (checker.readBooleanType(def.type.typeArguments[7]) ?? false);
         const inputs = ClassPropertyMapping.fromMappedObject(readInputsType(def.type.typeArguments[3]));
         const outputs = ClassPropertyMapping.fromMappedObject(checker.readMapType(def.type.typeArguments[4], checker.readStringType));
@@ -2615,6 +2791,10 @@ class DtsMetadataReader {
             ? readHostDirectivesType(this.checker, def.type.typeArguments[8], ref.bestGuessOwningModule)
             : null;
         const isSignal = def.type.typeArguments.length > 9 && (checker.readBooleanType(def.type.typeArguments[9]) ?? false);
+        // At this point in time, the `.d.ts` may not be fully extractable when
+        // trying to resolve host directive types to their declarations.
+        // If this cannot be done completely, the metadata is incomplete and "poisoned".
+        const isPoisoned = hostDirectives !== null && hostDirectives?.isIncomplete;
         return {
             kind: checker.MetaKind.Directive,
             matchSource: checker.MatchSource.Selector,
@@ -2625,11 +2805,11 @@ class DtsMetadataReader {
             exportAs: checker.readStringArrayType(def.type.typeArguments[2]),
             inputs,
             outputs,
-            hostDirectives,
+            hostDirectives: hostDirectives?.result ?? null,
             queries: checker.readStringArrayType(def.type.typeArguments[5]),
             ...checker.extractDirectiveTypeCheckMeta(clazz, inputs, this.reflector),
             baseClass: readBaseClass(clazz, this.checker, this.reflector),
-            isPoisoned: false,
+            isPoisoned,
             isStructural,
             animationTriggerNames: null,
             ngContentSelectors,
@@ -2771,21 +2951,27 @@ function readHostDirectivesType(checker$1, type, bestGuessOwningModule) {
         return null;
     }
     const result = [];
+    let isIncomplete = false;
     for (const hostDirectiveType of type.elements) {
         const { directive, inputs, outputs } = checker.readMapType(hostDirectiveType, (type) => type);
         if (directive) {
             if (!ts__default["default"].isTypeQueryNode(directive)) {
                 throw new Error(`Expected TypeQueryNode: ${checker.nodeDebugInfo(directive)}`);
             }
+            const ref = checker.extraReferenceFromTypeQuery(checker$1, directive, type, bestGuessOwningModule);
+            if (ref === null) {
+                isIncomplete = true;
+                continue;
+            }
             result.push({
-                directive: checker.extraReferenceFromTypeQuery(checker$1, directive, type, bestGuessOwningModule),
+                directive: ref,
                 isForwardReference: false,
                 inputs: checker.readMapType(inputs, checker.readStringType),
                 outputs: checker.readMapType(outputs, checker.readStringType),
             });
         }
     }
-    return result.length > 0 ? result : null;
+    return result.length > 0 ? { result, isIncomplete } : null;
 }
 
 /**
@@ -2867,11 +3053,9 @@ function flattenInheritedDirectiveMetadata(reader, dir) {
  * unit, which supports both reading and registering.
  */
 class LocalMetadataRegistry {
-    constructor() {
-        this.directives = new Map();
-        this.ngModules = new Map();
-        this.pipes = new Map();
-    }
+    directives = new Map();
+    ngModules = new Map();
+    pipes = new Map();
     getDirectiveMetadata(ref) {
         return this.directives.has(ref.node) ? this.directives.get(ref.node) : null;
     }
@@ -2906,6 +3090,7 @@ class LocalMetadataRegistry {
  * instances.
  */
 class CompoundMetadataRegistry {
+    registries;
     constructor(registries) {
         this.registries = registries;
     }
@@ -2934,12 +3119,10 @@ class CompoundMetadataRegistry {
  * assistance.
  */
 class ResourceRegistry {
-    constructor() {
-        this.externalTemplateToComponentsMap = new Map();
-        this.componentToTemplateMap = new Map();
-        this.componentToStylesMap = new Map();
-        this.externalStyleToComponentsMap = new Map();
-    }
+    externalTemplateToComponentsMap = new Map();
+    componentToTemplateMap = new Map();
+    componentToStylesMap = new Map();
+    externalStyleToComponentsMap = new Map();
     getComponentsWithTemplate(template) {
         if (!this.externalTemplateToComponentsMap.has(template)) {
             return new Set();
@@ -3002,14 +3185,15 @@ class ResourceRegistry {
  * the NgModule & standalone import graph.
  */
 class ExportedProviderStatusResolver {
+    metaReader;
+    /**
+     * `ClassDeclaration`s that we are in the process of determining the provider status for.
+     *
+     * This is used to detect cycles in the import graph and avoid getting stuck in them.
+     */
+    calculating = new Set();
     constructor(metaReader) {
         this.metaReader = metaReader;
-        /**
-         * `ClassDeclaration`s that we are in the process of determining the provider status for.
-         *
-         * This is used to detect cycles in the import graph and avoid getting stuck in them.
-         */
-        this.calculating = new Set();
     }
     /**
      * Determines whether `ref` may or may not export providers to NgModules which import it.
@@ -3080,9 +3264,10 @@ class ExportedProviderStatusResolver {
 const EMPTY_ARRAY$1 = [];
 /** Resolves the host directives of a directive to a flat array of matches. */
 class HostDirectivesResolver {
+    metaReader;
+    cache = new Map();
     constructor(metaReader) {
         this.metaReader = metaReader;
-        this.cache = new Map();
     }
     /** Resolves all of the host directives that apply to a directive. */
     resolve(metadata) {
@@ -3226,9 +3411,10 @@ function traceDynamicValue(node, value) {
     return value.accept(new TraceDynamicValueVisitor(node));
 }
 class TraceDynamicValueVisitor {
+    node;
+    currentContainerNode = null;
     constructor(node) {
         this.node = node;
-        this.currentContainerNode = null;
     }
     visitDynamicInput(value) {
         const trace = value.reason.accept(this);
@@ -3326,6 +3512,9 @@ function getContainerNode(node) {
 }
 
 class PartialEvaluator {
+    host;
+    checker;
+    dependencyTracker;
     constructor(host, checker, dependencyTracker) {
         this.host = host;
         this.checker = checker;
@@ -3380,6 +3569,12 @@ function timeSinceInMicros(mark) {
  * A `PerfRecorder` that actively tracks performance statistics.
  */
 class ActivePerfRecorder {
+    zeroTime;
+    counters;
+    phaseTime;
+    bytes;
+    currentPhase = checker.PerfPhase.Unaccounted;
+    currentPhaseEntered;
     /**
      * Creates an `ActivePerfRecorder` with its zero point set to the current time.
      */
@@ -3388,7 +3583,6 @@ class ActivePerfRecorder {
     }
     constructor(zeroTime) {
         this.zeroTime = zeroTime;
-        this.currentPhase = checker.PerfPhase.Unaccounted;
         this.currentPhaseEntered = this.zeroTime;
         this.counters = Array(checker.PerfEvent.LAST).fill(0);
         this.phaseTime = Array(checker.PerfPhase.LAST).fill(0);
@@ -3463,6 +3657,7 @@ class ActivePerfRecorder {
  * the same `NgCompiler` for a new compilation.
  */
 class DelegatingPerfRecorder {
+    target;
     constructor(target) {
         this.target = target;
     }
@@ -3503,6 +3698,32 @@ class DelegatingPerfRecorder {
  * class (like adding fields or type declarations).
  */
 class TraitCompiler {
+    handlers;
+    reflector;
+    perf;
+    incrementalBuild;
+    compileNonExportedClasses;
+    compilationMode;
+    dtsTransforms;
+    semanticDepGraphUpdater;
+    sourceFileTypeIdentifier;
+    /**
+     * Maps class declarations to their `ClassRecord`, which tracks the Ivy traits being applied to
+     * those classes.
+     */
+    classes = new Map();
+    /**
+     * Maps source files to any class declaration(s) within them which have been discovered to contain
+     * Ivy traits.
+     */
+    fileToClasses = new Map();
+    /**
+     * Tracks which source files have been analyzed but did not contain any traits. This set allows
+     * the compiler to skip analyzing these files in an incremental rebuild.
+     */
+    filesWithoutTraits = new Set();
+    reexportMap = new Map();
+    handlersByName = new Map();
     constructor(handlers, reflector, perf, incrementalBuild, compileNonExportedClasses, compilationMode, dtsTransforms, semanticDepGraphUpdater, sourceFileTypeIdentifier) {
         this.handlers = handlers;
         this.reflector = reflector;
@@ -3513,23 +3734,6 @@ class TraitCompiler {
         this.dtsTransforms = dtsTransforms;
         this.semanticDepGraphUpdater = semanticDepGraphUpdater;
         this.sourceFileTypeIdentifier = sourceFileTypeIdentifier;
-        /**
-         * Maps class declarations to their `ClassRecord`, which tracks the Ivy traits being applied to
-         * those classes.
-         */
-        this.classes = new Map();
-        /**
-         * Maps source files to any class declaration(s) within them which have been discovered to contain
-         * Ivy traits.
-         */
-        this.fileToClasses = new Map();
-        /**
-         * Tracks which source files have been analyzed but did not contain any traits. This set allows
-         * the compiler to skip analyzing these files in an incremental rebuild.
-         */
-        this.filesWithoutTraits = new Set();
-        this.reexportMap = new Map();
-        this.handlersByName = new Map();
         for (const handler of handlers) {
             this.handlersByName.set(handler.name, handler);
         }
@@ -4024,6 +4228,25 @@ class TraitCompiler {
         // Return the instruction to the transformer so the fields will be added.
         return res.length > 0 ? res : null;
     }
+    compileHmrUpdateCallback(clazz) {
+        const original = ts__default["default"].getOriginalNode(clazz);
+        if (!this.reflector.isClass(clazz) ||
+            !this.reflector.isClass(original) ||
+            !this.classes.has(original)) {
+            return null;
+        }
+        const record = this.classes.get(original);
+        for (const trait of record.traits) {
+            // Cannot compile a trait that is not resolved, or had any errors in its declaration.
+            if (trait.state === checker.TraitState.Resolved &&
+                trait.handler.compileHmrUpdateDeclaration !== undefined &&
+                !containsErrors(trait.analysisDiagnostics) &&
+                !containsErrors(trait.resolveDiagnostics)) {
+                return trait.handler.compileHmrUpdateDeclaration(clazz, trait.analysis, trait.resolution);
+            }
+        }
+        return null;
+    }
     decoratorsFor(node) {
         const original = ts__default["default"].getOriginalNode(node);
         if (!this.reflector.isClass(original) || !this.classes.has(original)) {
@@ -4075,9 +4298,7 @@ function containsErrors(diagnostics) {
  * have their declaration file transformed.
  */
 class DtsTransformRegistry {
-    constructor() {
-        this.ivyDeclarationTransforms = new Map();
-    }
+    ivyDeclarationTransforms = new Map();
     getIvyDeclarationTransform(sf) {
         if (!this.ivyDeclarationTransforms.has(sf)) {
             this.ivyDeclarationTransforms.set(sf, new IvyDeclarationDtsTransform());
@@ -4125,6 +4346,10 @@ function declarationTransformFactory(transformRegistry, reflector, refEmitter, i
  * Processes .d.ts file text and adds static field declarations, with types.
  */
 class DtsTransformer {
+    ctx;
+    reflector;
+    refEmitter;
+    importRewriter;
     constructor(ctx, reflector, refEmitter, importRewriter) {
         this.ctx = ctx;
         this.reflector = reflector;
@@ -4206,9 +4431,7 @@ class DtsTransformer {
     }
 }
 class IvyDeclarationDtsTransform {
-    constructor() {
-        this.declarationFields = new Map();
-    }
+    declarationFields = new Map();
     addFields(decl, fields) {
         this.declarationFields.set(decl, fields);
     }
@@ -4254,16 +4477,14 @@ function visit(node, visitor, context) {
  * of other nodes before them.
  */
 class Visitor {
-    constructor() {
-        /**
-         * Maps statements to an array of statements that should be inserted before them.
-         */
-        this._before = new Map();
-        /**
-         * Maps statements to an array of statements that should be inserted after them.
-         */
-        this._after = new Map();
-    }
+    /**
+     * Maps statements to an array of statements that should be inserted before them.
+     */
+    _before = new Map();
+    /**
+     * Maps statements to an array of statements that should be inserted after them.
+     */
+    _after = new Map();
     _visitListEntryNode(node, visitor) {
         const result = visitor(node);
         if (result.before !== undefined) {
@@ -4349,12 +4570,14 @@ function ivyTransformFactory(compilation, reflector, importRewriter, defaultImpo
  * does NOT perform any TS transformations.
  */
 class IvyCompilationVisitor extends Visitor {
+    compilation;
+    constantPool;
+    classCompilationMap = new Map();
+    deferrableImports = new Set();
     constructor(compilation, constantPool) {
         super();
         this.compilation = compilation;
         this.constantPool = constantPool;
-        this.classCompilationMap = new Map();
-        this.deferrableImports = new Set();
     }
     visitClassDeclaration(node) {
         // Determine if this class has an Ivy field that needs to be added, and compile the field
@@ -4379,6 +4602,14 @@ class IvyCompilationVisitor extends Visitor {
  * compilation results (provided as an argument).
  */
 class IvyTransformationVisitor extends Visitor {
+    compilation;
+    classCompilationMap;
+    reflector;
+    importManager;
+    recordWrappedNodeExpr;
+    isClosureCompilerEnabled;
+    isCore;
+    deferrableImports;
     constructor(compilation, classCompilationMap, reflector, importManager, recordWrappedNodeExpr, isClosureCompilerEnabled, isCore, deferrableImports) {
         super();
         this.compilation = compilation;
@@ -5036,10 +5267,12 @@ function compileDeclareFactory(metadata) {
  * injectables, directives, pipes).
  */
 class InjectableClassRegistry {
+    host;
+    isCore;
+    classes = new Map();
     constructor(host, isCore) {
         this.host = host;
         this.isCore = isCore;
-        this.classes = new Map();
     }
     registerInjectable(declaration, meta) {
         this.classes.set(declaration, meta);
@@ -5205,12 +5438,12 @@ function removeIdentifierReferences(node, names) {
     return result.transformed[0];
 }
 
-function extractClassDebugInfo(clazz, reflection, rootDirs, forbidOrphanRendering) {
+function extractClassDebugInfo(clazz, reflection, compilerHost, rootDirs, forbidOrphanRendering) {
     if (!reflection.isClass(clazz)) {
         return null;
     }
     const srcFile = clazz.getSourceFile();
-    const srcFileMaybeRelativePath = computeRelativePathIfPossible(srcFile.fileName, rootDirs);
+    const srcFileMaybeRelativePath = getProjectRelativePath(srcFile, rootDirs, compilerHost);
     return {
         type: new checker.WrappedNodeExpr(clazz.name),
         className: checker.literal(clazz.name.getText()),
@@ -5219,19 +5452,6 @@ function extractClassDebugInfo(clazz, reflection, rootDirs, forbidOrphanRenderin
         forbidOrphanRendering,
     };
 }
-/**
- * Computes a source file path relative to the project root folder if possible, otherwise returns
- * null.
- */
-function computeRelativePathIfPossible(filePath, rootDirs) {
-    for (const rootDir of rootDirs) {
-        const rel = p__namespace.relative(rootDir, filePath);
-        if (!rel.startsWith('..')) {
-            return rel;
-        }
-    }
-    return null;
-}
 
 /**
  * This registry does nothing.
@@ -5302,9 +5522,7 @@ function compileInputTransformFields(inputs) {
  * marked for JIT compilation and are skipping compilation by trait handlers.
  */
 class JitDeclarationRegistry {
-    constructor() {
-        this.jitDeclarations = new Set();
-    }
+    jitDeclarations = new Set();
 }
 
 /**
@@ -5314,6 +5532,21 @@ class JitDeclarationRegistry {
  * from the prior compilation.
  */
 class SemanticSymbol {
+    decl;
+    /**
+     * The path of the file that declares this symbol.
+     */
+    path;
+    /**
+     * The identifier of this symbol, or null if no identifier could be determined. It should
+     * uniquely identify the symbol relative to `file`. This is typically just the name of a
+     * top-level class declaration, as that uniquely identifies the class within the file.
+     *
+     * If the identifier is null, then this symbol cannot be recognized across rebuilds. In that
+     * case, the symbol is always assumed to have semantically changed to guarantee a proper
+     * rebuild.
+     */
+    identifier;
     constructor(
     /**
      * The declaration for this symbol.
@@ -5352,14 +5585,12 @@ class OpaqueSymbol extends SemanticSymbol {
  * The semantic dependency graph of a single compilation.
  */
 class SemanticDepGraph {
-    constructor() {
-        this.files = new Map();
-        // Note: the explicit type annotation is used to work around a CI failure on Windows:
-        // error TS2742: The inferred type of 'symbolByDecl' cannot be named without a reference to
-        // '../../../../../../../external/npm/node_modules/typescript/lib/typescript'. This is likely
-        // not portable. A type annotation is necessary.
-        this.symbolByDecl = new Map();
-    }
+    files = new Map();
+    // Note: the explicit type annotation is used to work around a CI failure on Windows:
+    // error TS2742: The inferred type of 'symbolByDecl' cannot be named without a reference to
+    // '../../../../../../../external/npm/node_modules/typescript/lib/typescript'. This is likely
+    // not portable. A type annotation is necessary.
+    symbolByDecl = new Map();
     /**
      * Registers a symbol in the graph. The symbol is given a unique identifier if possible, such that
      * its equivalent symbol can be obtained from a prior graph even if its declaration node has
@@ -5426,6 +5657,13 @@ class SemanticDepGraph {
  * on which files have been affected.
  */
 class SemanticDepGraphUpdater {
+    priorGraph;
+    newGraph = new SemanticDepGraph();
+    /**
+     * Contains opaque symbols that were created for declarations for which there was no symbol
+     * registered, which happens for e.g. external declarations.
+     */
+    opaqueSymbols = new Map();
     constructor(
     /**
      * The semantic dependency graph of the most recently succeeded compilation, or null if this
@@ -5433,12 +5671,6 @@ class SemanticDepGraphUpdater {
      */
     priorGraph) {
         this.priorGraph = priorGraph;
-        this.newGraph = new SemanticDepGraph();
-        /**
-         * Contains opaque symbols that were created for declarations for which there was no symbol
-         * registered, which happens for e.g. external declarations.
-         */
-        this.opaqueSymbols = new Map();
     }
     /**
      * Registers the symbol in the new graph that is being created.
@@ -5676,6 +5908,7 @@ function isTypeParameterEqual(a, b) {
  * registry and from the incremental state).
  */
 class CompoundComponentScopeReader {
+    readers;
     constructor(readers) {
         this.readers = readers;
     }
@@ -5707,16 +5940,18 @@ class CompoundComponentScopeReader {
  * fields on directives, components, pipes, and NgModules.
  */
 class MetadataDtsModuleScopeResolver {
+    dtsMetaReader;
+    aliasingHost;
+    /**
+     * Cache which holds fully resolved scopes for NgModule classes from .d.ts files.
+     */
+    cache = new Map();
     /**
      * @param dtsMetaReader a `MetadataReader` which can read metadata from `.d.ts` files.
      */
     constructor(dtsMetaReader, aliasingHost) {
         this.dtsMetaReader = dtsMetaReader;
         this.aliasingHost = aliasingHost;
-        /**
-         * Cache which holds fully resolved scopes for NgModule classes from .d.ts files.
-         */
-        this.cache = new Map();
     }
     /**
      * Resolve a `Reference`'d NgModule from a .d.ts file and produce a transitive `ExportScope`
@@ -5793,7 +6028,7 @@ class MetadataDtsModuleScopeResolver {
         const exportScope = {
             exported: {
                 dependencies,
-                isPoisoned: false,
+                isPoisoned: meta.isPoisoned,
             },
         };
         this.cache.set(clazz, exportScope);
@@ -5850,6 +6085,8 @@ function makeUnknownComponentDeferredImportDiagnostic(ref, rawExpr) {
     return checker.makeDiagnostic(checker.ErrorCode.COMPONENT_UNKNOWN_DEFERRED_IMPORT, getDiagnosticNode(ref, rawExpr), `Component deferred imports must be standalone components, directives or pipes.`);
 }
 
+/** Value used to mark a module whose scope is in the process of being resolved. */
+const IN_PROGRESS_RESOLUTION = {};
 /**
  * A registry which collects information about NgModules, Directives, Components, and Pipes which
  * are local (declared in the ts.Program being compiled), and can produce `LocalModuleScope`s
@@ -5870,54 +6107,59 @@ function makeUnknownComponentDeferredImportDiagnostic(ref, rawExpr) {
  * semantics are violated.
  */
 class LocalModuleScopeRegistry {
+    localReader;
+    fullReader;
+    dependencyScopeReader;
+    refEmitter;
+    aliasingHost;
+    /**
+     * Tracks whether the registry has been asked to produce scopes for a module or component. Once
+     * this is true, the registry cannot accept registrations of new directives/pipes/modules as it
+     * would invalidate the cached scope data.
+     */
+    sealed = false;
+    /**
+     * A map of components from the current compilation unit to the NgModule which declared them.
+     *
+     * As components and directives are not distinguished at the NgModule level, this map may also
+     * contain directives. This doesn't cause any problems but isn't useful as there is no concept of
+     * a directive's compilation scope.
+     */
+    declarationToModule = new Map();
+    /**
+     * This maps from the directive/pipe class to a map of data for each NgModule that declares the
+     * directive/pipe. This data is needed to produce an error for the given class.
+     */
+    duplicateDeclarations = new Map();
+    moduleToRef = new Map();
+    /**
+     * A cache of calculated `LocalModuleScope`s for each NgModule declared in the current program.
+  
+     */
+    cache = new Map();
+    /**
+     * Tracks the `RemoteScope` for components requiring "remote scoping".
+     *
+     * Remote scoping is when the set of directives which apply to a given component is set in the
+     * NgModule's file instead of directly on the component def (which is sometimes needed to get
+     * around cyclic import issues). This is not used in calculation of `LocalModuleScope`s, but is
+     * tracked here for convenience.
+     */
+    remoteScoping = new Map();
+    /**
+     * Tracks errors accumulated in the processing of scopes for each module declaration.
+     */
+    scopeErrors = new Map();
+    /**
+     * Tracks which NgModules have directives/pipes that are declared in more than one module.
+     */
+    modulesWithStructuralErrors = new Set();
     constructor(localReader, fullReader, dependencyScopeReader, refEmitter, aliasingHost) {
         this.localReader = localReader;
         this.fullReader = fullReader;
         this.dependencyScopeReader = dependencyScopeReader;
         this.refEmitter = refEmitter;
         this.aliasingHost = aliasingHost;
-        /**
-         * Tracks whether the registry has been asked to produce scopes for a module or component. Once
-         * this is true, the registry cannot accept registrations of new directives/pipes/modules as it
-         * would invalidate the cached scope data.
-         */
-        this.sealed = false;
-        /**
-         * A map of components from the current compilation unit to the NgModule which declared them.
-         *
-         * As components and directives are not distinguished at the NgModule level, this map may also
-         * contain directives. This doesn't cause any problems but isn't useful as there is no concept of
-         * a directive's compilation scope.
-         */
-        this.declarationToModule = new Map();
-        /**
-         * This maps from the directive/pipe class to a map of data for each NgModule that declares the
-         * directive/pipe. This data is needed to produce an error for the given class.
-         */
-        this.duplicateDeclarations = new Map();
-        this.moduleToRef = new Map();
-        /**
-         * A cache of calculated `LocalModuleScope`s for each NgModule declared in the current program.
-      
-         */
-        this.cache = new Map();
-        /**
-         * Tracks the `RemoteScope` for components requiring "remote scoping".
-         *
-         * Remote scoping is when the set of directives which apply to a given component is set in the
-         * NgModule's file instead of directly on the component def (which is sometimes needed to get
-         * around cyclic import issues). This is not used in calculation of `LocalModuleScope`s, but is
-         * tracked here for convenience.
-         */
-        this.remoteScoping = new Map();
-        /**
-         * Tracks errors accumulated in the processing of scopes for each module declaration.
-         */
-        this.scopeErrors = new Map();
-        /**
-         * Tracks which NgModules have directives/pipes that are declared in more than one module.
-         */
-        this.modulesWithStructuralErrors = new Set();
     }
     /**
      * Add an NgModule's data to the registry.
@@ -6021,8 +6263,12 @@ class LocalModuleScopeRegistry {
      */
     getScopeOfModuleReference(ref) {
         if (this.cache.has(ref.node)) {
-            return this.cache.get(ref.node);
+            const cachedValue = this.cache.get(ref.node);
+            if (cachedValue !== IN_PROGRESS_RESOLUTION) {
+                return cachedValue;
+            }
         }
+        this.cache.set(ref.node, IN_PROGRESS_RESOLUTION);
         // Seal the registry to protect the integrity of the `LocalModuleScope` cache.
         this.sealed = true;
         // `ref` should be an NgModule previously added to the registry. If not, a scope for it
@@ -6067,13 +6313,18 @@ class LocalModuleScopeRegistry {
         for (const decl of ngModule.imports) {
             const importScope = this.getExportedScope(decl, diagnostics, ref.node, 'import');
             if (importScope !== null) {
-                if (importScope === 'invalid' || importScope.exported.isPoisoned) {
+                if (importScope === 'invalid' ||
+                    importScope === 'cycle' ||
+                    importScope.exported.isPoisoned) {
                     // An import was an NgModule but contained errors of its own. Record this as an error too,
                     // because this scope is always going to be incorrect if one of its imports could not be
                     // read.
-                    diagnostics.push(invalidTransitiveNgModuleRef(decl, ngModule.rawImports, 'import'));
                     isPoisoned = true;
-                    if (importScope === 'invalid') {
+                    // Prevent the module from reporting a diagnostic about itself when there's a cycle.
+                    if (importScope !== 'cycle') {
+                        diagnostics.push(invalidTransitiveNgModuleRef(decl, ngModule.rawImports, 'import'));
+                    }
+                    if (importScope === 'invalid' || importScope === 'cycle') {
                         continue;
                     }
                 }
@@ -6159,13 +6410,18 @@ class LocalModuleScopeRegistry {
         for (const decl of ngModule.exports) {
             // Attempt to resolve decl as an NgModule.
             const exportScope = this.getExportedScope(decl, diagnostics, ref.node, 'export');
-            if (exportScope === 'invalid' || (exportScope !== null && exportScope.exported.isPoisoned)) {
+            if (exportScope === 'invalid' ||
+                exportScope === 'cycle' ||
+                (exportScope !== null && exportScope.exported.isPoisoned)) {
                 // An export was an NgModule but contained errors of its own. Record this as an error too,
                 // because this scope is always going to be incorrect if one of its exports could not be
                 // read.
-                diagnostics.push(invalidTransitiveNgModuleRef(decl, ngModule.rawExports, 'export'));
                 isPoisoned = true;
-                if (exportScope === 'invalid') {
+                // Prevent the module from reporting a diagnostic about itself when there's a cycle.
+                if (exportScope !== 'cycle') {
+                    diagnostics.push(invalidTransitiveNgModuleRef(decl, ngModule.rawExports, 'export'));
+                }
+                if (exportScope === 'invalid' || exportScope === 'cycle') {
                     continue;
                 }
             }
@@ -6270,6 +6526,12 @@ class LocalModuleScopeRegistry {
             return this.dependencyScopeReader.resolve(ref);
         }
         else {
+            if (this.cache.get(ref.node) === IN_PROGRESS_RESOLUTION) {
+                diagnostics.push(checker.makeDiagnostic(type === 'import'
+                    ? checker.ErrorCode.NGMODULE_INVALID_IMPORT
+                    : checker.ErrorCode.NGMODULE_INVALID_EXPORT, checker.identifierOfNode(ref.node) || ref.node, `NgModule "${type}" field contains a cycle`));
+                return 'cycle';
+            }
             // The NgModule is declared locally in the current program. Resolve it from the registry.
             return this.getScopeOfModuleReference(ref);
         }
@@ -6423,19 +6685,22 @@ function reexportCollision(module, refA, refB) {
  * Computes scope information to be used in template type checking.
  */
 class TypeCheckScopeRegistry {
+    scopeReader;
+    metaReader;
+    hostDirectivesResolver;
+    /**
+     * Cache of flattened directive metadata. Because flattened metadata is scope-invariant it's
+     * cached individually, such that all scopes refer to the same flattened metadata.
+     */
+    flattenedDirectiveMetaCache = new Map();
+    /**
+     * Cache of the computed type check scope per NgModule declaration.
+     */
+    scopeCache = new Map();
     constructor(scopeReader, metaReader, hostDirectivesResolver) {
         this.scopeReader = scopeReader;
         this.metaReader = metaReader;
         this.hostDirectivesResolver = hostDirectivesResolver;
-        /**
-         * Cache of flattened directive metadata. Because flattened metadata is scope-invariant it's
-         * cached individually, such that all scopes refer to the same flattened metadata.
-         */
-        this.flattenedDirectiveMetaCache = new Map();
-        /**
-         * Cache of the computed type check scope per NgModule declaration.
-         */
-        this.scopeCache = new Map();
     }
     /**
      * Computes the type-check scope information for the component declaration. If the NgModule
@@ -6532,7 +6797,7 @@ const QUERY_TYPES = new Set(queryDecoratorNames);
  * appear in the declarations of an `NgModule` and additional verification is done when processing
  * the module.
  */
-function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, evaluator, refEmitter, referencesRegistry, isCore, annotateForClosureCompiler, compilationMode, defaultSelector, strictStandalone) {
+function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, evaluator, refEmitter, referencesRegistry, isCore, annotateForClosureCompiler, compilationMode, defaultSelector, strictStandalone, implicitStandaloneValue) {
     let directive;
     if (decorator.args === null || decorator.args.length === 0) {
         directive = new Map();
@@ -6636,7 +6901,7 @@ function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, ev
         ctorDeps.some((dep) => dep.token instanceof checker.ExternalExpr &&
             dep.token.value.moduleName === '@angular/core' &&
             dep.token.value.name === 'TemplateRef');
-    let isStandalone = false;
+    let isStandalone = implicitStandaloneValue;
     if (directive.has('standalone')) {
         const expr = directive.get('standalone');
         const resolved = evaluator.evaluate(expr);
@@ -7513,6 +7778,13 @@ function toR3InputMetadata(mapping) {
  * from this symbol.
  */
 class DirectiveSymbol extends SemanticSymbol {
+    selector;
+    inputs;
+    outputs;
+    exportAs;
+    typeCheckMeta;
+    typeParameters;
+    baseClass = null;
     constructor(decl, selector, inputs, outputs, exportAs, typeCheckMeta, typeParameters) {
         super(decl);
         this.selector = selector;
@@ -7521,7 +7793,6 @@ class DirectiveSymbol extends SemanticSymbol {
         this.exportAs = exportAs;
         this.typeCheckMeta = typeCheckMeta;
         this.typeParameters = typeParameters;
-        this.baseClass = null;
     }
     isPublicApiAffected(previousSymbol) {
         // Note: since components and directives have exactly the same items contributing to their
@@ -7640,7 +7911,26 @@ const LIFECYCLE_HOOKS = new Set([
     'ngAfterContentChecked',
 ]);
 class DirectiveDecoratorHandler {
-    constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, annotateForClosureCompiler, perf, importTracker, includeClassMetadata, compilationMode, jitDeclarationRegistry, strictStandalone) {
+    reflector;
+    evaluator;
+    metaRegistry;
+    scopeRegistry;
+    metaReader;
+    injectableRegistry;
+    refEmitter;
+    referencesRegistry;
+    isCore;
+    strictCtorDeps;
+    semanticDepGraphUpdater;
+    annotateForClosureCompiler;
+    perf;
+    importTracker;
+    includeClassMetadata;
+    compilationMode;
+    jitDeclarationRegistry;
+    strictStandalone;
+    implicitStandaloneValue;
+    constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, annotateForClosureCompiler, perf, importTracker, includeClassMetadata, compilationMode, jitDeclarationRegistry, strictStandalone, implicitStandaloneValue) {
         this.reflector = reflector;
         this.evaluator = evaluator;
         this.metaRegistry = metaRegistry;
@@ -7659,9 +7949,10 @@ class DirectiveDecoratorHandler {
         this.compilationMode = compilationMode;
         this.jitDeclarationRegistry = jitDeclarationRegistry;
         this.strictStandalone = strictStandalone;
-        this.precedence = checker.HandlerPrecedence.PRIMARY;
-        this.name = 'DirectiveDecoratorHandler';
+        this.implicitStandaloneValue = implicitStandaloneValue;
     }
+    precedence = checker.HandlerPrecedence.PRIMARY;
+    name = 'DirectiveDecoratorHandler';
     detect(node, decorators) {
         // If a class is undecorated but uses Angular features, we detect it as an
         // abstract directive. This is an unsupported pattern as of v10, but we want
@@ -7692,7 +7983,7 @@ class DirectiveDecoratorHandler {
         }
         this.perf.eventCount(checker.PerfEvent.AnalyzeDirective);
         const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.importTracker, this.evaluator, this.refEmitter, this.referencesRegistry, this.isCore, this.annotateForClosureCompiler, this.compilationMode, 
-        /* defaultSelector */ null, this.strictStandalone);
+        /* defaultSelector */ null, this.strictStandalone, this.implicitStandaloneValue);
         // `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.
@@ -7955,20 +8246,21 @@ function isResolvedModuleWithProviders(sv) {
  * Represents an Angular NgModule.
  */
 class NgModuleSymbol extends SemanticSymbol {
+    hasProviders;
+    remotelyScopedComponents = [];
+    /**
+     * `SemanticSymbol`s of the transitive imports of this NgModule which came from imported
+     * standalone components.
+     *
+     * Standalone components are excluded/included in the `InjectorDef` emit output of the NgModule
+     * based on whether the compiler can prove that their transitive imports may contain exported
+     * providers, so a change in this set of symbols may affect the compilation output of this
+     * NgModule.
+     */
+    transitiveImportsFromStandaloneComponents = new Set();
     constructor(decl, hasProviders) {
         super(decl);
         this.hasProviders = hasProviders;
-        this.remotelyScopedComponents = [];
-        /**
-         * `SemanticSymbol`s of the transitive imports of this NgModule which came from imported
-         * standalone components.
-         *
-         * Standalone components are excluded/included in the `InjectorDef` emit output of the NgModule
-         * based on whether the compiler can prove that their transitive imports may contain exported
-         * providers, so a change in this set of symbols may affect the compilation output of this
-         * NgModule.
-         */
-        this.transitiveImportsFromStandaloneComponents = new Set();
     }
     isPublicApiAffected(previousSymbol) {
         if (!(previousSymbol instanceof NgModuleSymbol)) {
@@ -8043,6 +8335,25 @@ class NgModuleSymbol extends SemanticSymbol {
  * Compiles @NgModule annotations to ngModuleDef fields.
  */
 class NgModuleDecoratorHandler {
+    reflector;
+    evaluator;
+    metaReader;
+    metaRegistry;
+    scopeRegistry;
+    referencesRegistry;
+    exportedProviderStatusResolver;
+    semanticDepGraphUpdater;
+    isCore;
+    refEmitter;
+    annotateForClosureCompiler;
+    onlyPublishPublicTypings;
+    injectableRegistry;
+    perf;
+    includeClassMetadata;
+    includeSelectorScope;
+    compilationMode;
+    localCompilationExtraImportsTracker;
+    jitDeclarationRegistry;
     constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, annotateForClosureCompiler, onlyPublishPublicTypings, injectableRegistry, perf, includeClassMetadata, includeSelectorScope, compilationMode, localCompilationExtraImportsTracker, jitDeclarationRegistry) {
         this.reflector = reflector;
         this.evaluator = evaluator;
@@ -8063,9 +8374,9 @@ class NgModuleDecoratorHandler {
         this.compilationMode = compilationMode;
         this.localCompilationExtraImportsTracker = localCompilationExtraImportsTracker;
         this.jitDeclarationRegistry = jitDeclarationRegistry;
-        this.precedence = checker.HandlerPrecedence.PRIMARY;
-        this.name = 'NgModuleDecoratorHandler';
     }
+    precedence = checker.HandlerPrecedence.PRIMARY;
+    name = 'NgModuleDecoratorHandler';
     detect(node, decorators) {
         if (!decorators) {
             return undefined;
@@ -8388,6 +8699,7 @@ class NgModuleDecoratorHandler {
             rawExports: analysis.rawExports,
             decorator: analysis.decorator,
             mayDeclareProviders: analysis.providers !== null,
+            isPoisoned: false,
         });
         this.injectableRegistry.registerInjectable(node, {
             ctorDeps: analysis.fac.deps,
@@ -9166,12 +9478,9 @@ function _extractTemplateStyleUrls(template) {
  * Represents an Angular component.
  */
 class ComponentSymbol extends DirectiveSymbol {
-    constructor() {
-        super(...arguments);
-        this.usedDirectives = [];
-        this.usedPipes = [];
-        this.isRemotelyScoped = false;
-    }
+    usedDirectives = [];
+    usedPipes = [];
+    isRemotelyScoped = false;
     isEmitAffected(previousSymbol, publicApiAffected) {
         if (!(previousSymbol instanceof ComponentSymbol)) {
             return true;
@@ -9346,39 +9655,47 @@ function makeShimFileName(fileName, suffix) {
  * (which already may contain shim files and thus have a different creation flow).
  */
 class ShimAdapter {
+    delegate;
+    /**
+     * A map of shim file names to the `ts.SourceFile` generated for those shims.
+     */
+    shims = new Map();
+    /**
+     * A map of shim file names to existing shims which were part of a previous iteration of this
+     * program.
+     *
+     * Not all of these shims will be inherited into this program.
+     */
+    priorShims = new Map();
+    /**
+     * File names which are already known to not be shims.
+     *
+     * This allows for short-circuit returns without the expense of running regular expressions
+     * against the filename repeatedly.
+     */
+    notShims = new Set();
+    /**
+     * The shim generators supported by this adapter as well as extra precalculated data facilitating
+     * their use.
+     */
+    generators = [];
+    /**
+     * A `Set` of shim `ts.SourceFile`s which should not be emitted.
+     */
+    ignoreForEmit = new Set();
+    /**
+     * A list of extra filenames which should be considered inputs to program creation.
+     *
+     * This includes any top-level shims generated for the program, as well as per-file shim names for
+     * those files which are included in the root files of the program.
+     */
+    extraInputFiles;
+    /**
+     * Extension prefixes of all installed per-file shims.
+     */
+    extensionPrefixes = [];
     constructor(delegate, tsRootFiles, topLevelGenerators, perFileGenerators, oldProgram) {
         this.delegate = delegate;
-        /**
-         * A map of shim file names to the `ts.SourceFile` generated for those shims.
-         */
-        this.shims = new Map();
-        /**
-         * A map of shim file names to existing shims which were part of a previous iteration of this
-         * program.
-         *
-         * Not all of these shims will be inherited into this program.
-         */
-        this.priorShims = new Map();
-        /**
-         * File names which are already known to not be shims.
-         *
-         * This allows for short-circuit returns without the expense of running regular expressions
-         * against the filename repeatedly.
-         */
-        this.notShims = new Set();
-        /**
-         * The shim generators supported by this adapter as well as extra precalculated data facilitating
-         * their use.
-         */
-        this.generators = [];
-        /**
-         * A `Set` of shim `ts.SourceFile`s which should not be emitted.
-         */
-        this.ignoreForEmit = new Set();
-        /**
-         * Extension prefixes of all installed per-file shims.
-         */
-        this.extensionPrefixes = [];
         // Initialize `this.generators` with a regex that matches each generator's paths.
         for (const gen of perFileGenerators) {
             // This regex matches paths for shims from this generator. The first (and only) capture group
@@ -9516,17 +9833,18 @@ class ShimAdapter {
  * `ShimReferenceTagger`s are intended to operate during program creation only.
  */
 class ShimReferenceTagger {
+    suffixes;
+    /**
+     * Tracks which original files have been processed and had shims generated if necessary.
+     *
+     * This is used to avoid generating shims twice for the same file.
+     */
+    tagged = new Set();
+    /**
+     * Whether shim tagging is currently being performed.
+     */
+    enabled = true;
     constructor(shimExtensions) {
-        /**
-         * Tracks which original files have been processed and had shims generated if necessary.
-         *
-         * This is used to avoid generating shims twice for the same file.
-         */
-        this.tagged = new Set();
-        /**
-         * Whether shim tagging is currently being performed.
-         */
-        this.enabled = true;
         this.suffixes = shimExtensions.map((extension) => `.${extension}.ts`);
     }
     /**
@@ -9576,6 +9894,30 @@ class ShimReferenceTagger {
  * generated for this class.
  */
 class DelegatingCompilerHost$1 {
+    delegate;
+    createHash;
+    directoryExists;
+    getCancellationToken;
+    getCanonicalFileName;
+    getCurrentDirectory;
+    getDefaultLibFileName;
+    getDefaultLibLocation;
+    getDirectories;
+    getEnvironmentVariable;
+    getNewLine;
+    getParsedCommandLine;
+    getSourceFileByPath;
+    readDirectory;
+    readFile;
+    realpath;
+    resolveModuleNames;
+    resolveTypeReferenceDirectives;
+    trace;
+    useCaseSensitiveFileNames;
+    getModuleResolutionCache;
+    hasInvalidatedResolutions;
+    resolveModuleNameLiterals;
+    resolveTypeReferenceDirectiveReferences;
     // jsDocParsingMode is not a method like the other elements above
     // TODO: ignore usage can be dropped once 5.2 support is dropped
     get jsDocParsingMode() {
@@ -9624,6 +9966,23 @@ class DelegatingCompilerHost$1 {
  * A `ts.CompilerHost` which augments source files.
  */
 class UpdatedProgramHost extends DelegatingCompilerHost$1 {
+    originalProgram;
+    shimExtensionPrefixes;
+    /**
+     * Map of source file names to `ts.SourceFile` instances.
+     */
+    sfMap;
+    /**
+     * The `ShimReferenceTagger` responsible for tagging `ts.SourceFile`s loaded via this host.
+     *
+     * The `UpdatedProgramHost` is used in the creation of a new `ts.Program`. Even though this new
+     * program is based on a prior one, TypeScript will still start from the root files and enumerate
+     * all source files to include in the new program.  This means that just like during the original
+     * program's creation, these source files must be tagged with references to per-file shims in
+     * order for those shims to be loaded, and then cleaned up afterwards. Thus the
+     * `UpdatedProgramHost` has its own `ShimReferenceTagger` to perform this function.
+     */
+    shimTagger;
     constructor(sfMap, originalProgram, delegate, shimExtensionPrefixes) {
         super(delegate);
         this.originalProgram = originalProgram;
@@ -9673,21 +10032,26 @@ class UpdatedProgramHost extends DelegatingCompilerHost$1 {
  * TypeScript compiler APIs for incremental program creation.
  */
 class TsCreateProgramDriver {
+    originalProgram;
+    originalHost;
+    options;
+    shimExtensionPrefixes;
+    /**
+     * A map of source file paths to replacement `ts.SourceFile`s for those paths.
+     *
+     * Effectively, this tracks the delta between the user's program (represented by the
+     * `originalHost`) and the template type-checking program being managed.
+     */
+    sfMap = new Map();
+    program;
     constructor(originalProgram, originalHost, options, shimExtensionPrefixes) {
         this.originalProgram = originalProgram;
         this.originalHost = originalHost;
         this.options = options;
         this.shimExtensionPrefixes = shimExtensionPrefixes;
-        /**
-         * A map of source file paths to replacement `ts.SourceFile`s for those paths.
-         *
-         * Effectively, this tracks the delta between the user's program (represented by the
-         * `originalHost`) and the template type-checking program being managed.
-         */
-        this.sfMap = new Map();
-        this.supportsInlineOperations = true;
         this.program = this.originalProgram;
     }
+    supportsInlineOperations = true;
     getProgram() {
         return this.program;
     }
@@ -9730,6 +10094,275 @@ class TsCreateProgramDriver {
     }
 }
 
+/*!
+ * @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
+ */
+/**
+ * Determines the names of the file-level locals that the HMR
+ * initializer needs to capture and pass along.
+ * @param sourceFile File in which the file is being compiled.
+ * @param definition Compiled component definition.
+ * @param factory Compiled component factory.
+ * @param classMetadata Compiled `setClassMetadata` expression, if any.
+ * @param debugInfo Compiled `setClassDebugInfo` expression, if any.
+ */
+function extractHmrLocals(node, definition, factory, classMetadata, debugInfo) {
+    const name = ts__default["default"].isClassDeclaration(node) && node.name ? node.name.text : null;
+    const visitor = new PotentialTopLevelReadsVisitor();
+    const sourceFile = node.getSourceFile();
+    // Visit all of the compiled expression to look for potential
+    // local references that would have to be retained.
+    definition.expression.visitExpression(visitor, null);
+    definition.statements.forEach((statement) => statement.visitStatement(visitor, null));
+    factory.initializer?.visitExpression(visitor, null);
+    factory.statements.forEach((statement) => statement.visitStatement(visitor, null));
+    classMetadata?.visitStatement(visitor, null);
+    debugInfo?.visitStatement(visitor, null);
+    // Filter out only the references to defined top-level symbols. This allows us to ignore local
+    // variables inside of functions. Note that we filter out the class name since it is always
+    // defined and it saves us having to repeat this logic wherever the locals are consumed.
+    const availableTopLevel = getTopLevelDeclarationNames(sourceFile);
+    return Array.from(visitor.allReads).filter((r) => r !== name && availableTopLevel.has(r));
+}
+/**
+ * Gets the names of all top-level declarations within the file (imports, declared classes etc).
+ * @param sourceFile File in which to search for locals.
+ */
+function getTopLevelDeclarationNames(sourceFile) {
+    const results = new Set();
+    // Only look through the top-level statements.
+    for (const node of sourceFile.statements) {
+        // Class, function and const enum declarations need to be captured since they correspond
+        // to runtime code. Intentionally excludes interfaces and type declarations.
+        if (ts__default["default"].isClassDeclaration(node) ||
+            ts__default["default"].isFunctionDeclaration(node) ||
+            (ts__default["default"].isEnumDeclaration(node) &&
+                !node.modifiers?.some((m) => m.kind === ts__default["default"].SyntaxKind.ConstKeyword))) {
+            if (node.name) {
+                results.add(node.name.text);
+            }
+            continue;
+        }
+        // Variable declarations.
+        if (ts__default["default"].isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                trackBindingName(decl.name, results);
+            }
+            continue;
+        }
+        // Import declarations.
+        if (ts__default["default"].isImportDeclaration(node) && node.importClause) {
+            const importClause = node.importClause;
+            // Skip over type-only imports since they won't be emitted to JS.
+            if (importClause.isTypeOnly) {
+                continue;
+            }
+            // import foo from 'foo'
+            if (importClause.name) {
+                results.add(importClause.name.text);
+            }
+            if (importClause.namedBindings) {
+                const namedBindings = importClause.namedBindings;
+                if (ts__default["default"].isNamespaceImport(namedBindings)) {
+                    // import * as foo from 'foo';
+                    results.add(namedBindings.name.text);
+                }
+                else {
+                    // import {foo} from 'foo';
+                    namedBindings.elements.forEach((el) => {
+                        if (!el.isTypeOnly) {
+                            results.add(el.name.text);
+                        }
+                    });
+                }
+            }
+            continue;
+        }
+    }
+    return results;
+}
+/**
+ * Adds all the variables declared through a `ts.BindingName` to a set of results.
+ * @param node Node from which to start searching for variables.
+ * @param results Set to which to add the matches.
+ */
+function trackBindingName(node, results) {
+    if (ts__default["default"].isIdentifier(node)) {
+        results.add(node.text);
+    }
+    else {
+        for (const el of node.elements) {
+            if (!ts__default["default"].isOmittedExpression(el)) {
+                trackBindingName(el.name, results);
+            }
+        }
+    }
+}
+/**
+ * Visitor that will traverse an AST looking for potential top-level variable reads.
+ * The reads are "potential", because the visitor doesn't account for local variables
+ * inside functions.
+ */
+class PotentialTopLevelReadsVisitor extends checker.RecursiveAstVisitor {
+    allReads = new Set();
+    visitReadVarExpr(ast, context) {
+        this.allReads.add(ast.name);
+        super.visitReadVarExpr(ast, context);
+    }
+    visitWrappedNodeExpr(ast, context) {
+        if (this.isTypeScriptNode(ast.node)) {
+            this.addAllTopLevelIdentifiers(ast.node);
+        }
+        super.visitWrappedNodeExpr(ast, context);
+    }
+    /**
+     * Traverses a TypeScript AST and tracks all the top-level reads.
+     * @param node Node from which to start the traversal.
+     */
+    addAllTopLevelIdentifiers = (node) => {
+        if (ts__default["default"].isIdentifier(node) && this.isTopLevelIdentifierReference(node)) {
+            this.allReads.add(node.text);
+        }
+        else {
+            ts__default["default"].forEachChild(node, this.addAllTopLevelIdentifiers);
+        }
+    };
+    /**
+     * TypeScript identifiers are used both when referring to a variable (e.g. `console.log(foo)`)
+     * and for names (e.g. `{foo: 123}`). This function determines if the identifier is a top-level
+     * variable read, rather than a nested name.
+     * @param node Identifier to check.
+     */
+    isTopLevelIdentifierReference(node) {
+        const parent = node.parent;
+        // The parent might be undefined for a synthetic node or if `setParentNodes` is set to false
+        // when the SourceFile was created. We can account for such cases using the type checker, at
+        // the expense of performance. At the moment of writing, we're keeping it simple since the
+        // compiler sets `setParentNodes: true`.
+        if (!parent) {
+            return false;
+        }
+        // Identifier referenced at the top level. Unlikely.
+        if (ts__default["default"].isSourceFile(parent) ||
+            (ts__default["default"].isExpressionStatement(parent) && parent.expression === node)) {
+            return true;
+        }
+        // Identifier used inside a call is only top-level if it's an argument.
+        // This also covers decorators since their expression is usually a call.
+        if (ts__default["default"].isCallExpression(parent)) {
+            return parent.expression === node || parent.arguments.includes(node);
+        }
+        // Identifier used in a property read is only top-level if it's the expression.
+        if (ts__default["default"].isPropertyAccessExpression(parent)) {
+            return parent.expression === node;
+        }
+        // Identifier used in an array is only top-level if it's one of the elements.
+        if (ts__default["default"].isArrayLiteralExpression(parent)) {
+            return parent.elements.includes(node);
+        }
+        // Identifier in a property assignment is only top level if it's the initializer.
+        if (ts__default["default"].isPropertyAssignment(parent)) {
+            return parent.initializer === node;
+        }
+        // Identifier in a class is only top level if it's the name.
+        if (ts__default["default"].isClassDeclaration(parent)) {
+            return parent.name === node;
+        }
+        // Otherwise it's not top-level.
+        return false;
+    }
+    /** Checks if a value is a TypeScript AST node. */
+    isTypeScriptNode(value) {
+        // If this is too permissive, we can also check for `getSourceFile`. This code runs
+        // on a narrow set of use cases so checking for `kind` should be enough.
+        return !!value && typeof value.kind === 'number';
+    }
+}
+
+/*!
+ * @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
+ */
+/**
+ * Extracts the HMR metadata for a class declaration.
+ * @param clazz Class being analyzed.
+ * @param reflection Reflection host.
+ * @param compilerHost Compiler host to use when resolving file names.
+ * @param rootDirs Root directories configured by the user.
+ * @param definition Analyzed component definition.
+ * @param factory Analyzed component factory.
+ * @param classMetadata Analyzed `setClassMetadata` expression, if any.
+ * @param debugInfo Analyzed `setClassDebugInfo` expression, if any.
+ */
+function extractHmrMetatadata(clazz, reflection, compilerHost, rootDirs, definition, factory, classMetadata, debugInfo) {
+    if (!reflection.isClass(clazz)) {
+        return null;
+    }
+    const sourceFile = clazz.getSourceFile();
+    const filePath = getProjectRelativePath(sourceFile, rootDirs, compilerHost) ||
+        compilerHost.getCanonicalFileName(sourceFile.fileName);
+    const meta = {
+        type: new checker.WrappedNodeExpr(clazz.name),
+        className: clazz.name.text,
+        filePath,
+        locals: extractHmrLocals(clazz, definition, factory, classMetadata, debugInfo),
+        coreName: '__ngCore__',
+    };
+    return meta;
+}
+
+/*!
+ * @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
+ */
+/**
+ * Gets the declaration for the function that replaces the metadata of a class during HMR.
+ * @param compilationResults Code generated for the class during compilation.
+ * @param meta HMR metadata about the class.
+ * @param sourceFile File in which the class is defined.
+ */
+function getHmrUpdateDeclaration(compilationResults, constantStatements, meta, sourceFile) {
+    const importRewriter = new HmrModuleImportRewriter(meta.coreName);
+    const importManager = new checker.ImportManager({
+        ...checker.presetImportManagerForceNamespaceImports,
+        rewriter: importRewriter,
+    });
+    const callback = compileHmrUpdateCallback(compilationResults, constantStatements, meta);
+    const node = checker.translateStatement(sourceFile, callback, importManager);
+    // The output AST doesn't support modifiers so we have to emit to
+    // TS and then update the declaration to add `export default`.
+    return ts__default["default"].factory.updateFunctionDeclaration(node, [
+        ts__default["default"].factory.createToken(ts__default["default"].SyntaxKind.ExportKeyword),
+        ts__default["default"].factory.createToken(ts__default["default"].SyntaxKind.DefaultKeyword),
+    ], node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
+}
+/** Rewriter that replaces namespace imports to `@angular/core` with a specifier identifier. */
+class HmrModuleImportRewriter {
+    coreName;
+    constructor(coreName) {
+        this.coreName = coreName;
+    }
+    rewriteNamespaceImportIdentifier(specifier, moduleName) {
+        return moduleName === '@angular/core' ? this.coreName : specifier;
+    }
+    rewriteSymbol(symbol) {
+        return symbol;
+    }
+    rewriteSpecifier(specifier) {
+        return specifier;
+    }
+}
+
 const EMPTY_ARRAY = [];
 const isUsedDirective = (decl) => decl.kind === checker.R3TemplateDependencyKind.Directive;
 const isUsedPipe = (decl) => decl.kind === checker.R3TemplateDependencyKind.Pipe;
@@ -9737,13 +10370,56 @@ const isUsedPipe = (decl) => decl.kind === checker.R3TemplateDependencyKind.Pipe
  * `DecoratorHandler` which handles the `@Component` annotation.
  */
 class ComponentDecoratorHandler {
-    constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, dtsScopeReader, 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) {
+    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;
+    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) {
         this.reflector = reflector;
         this.evaluator = evaluator;
         this.metaRegistry = metaRegistry;
         this.metaReader = metaReader;
         this.scopeReader = scopeReader;
-        this.dtsScopeReader = dtsScopeReader;
+        this.compilerHost = compilerHost;
         this.scopeRegistry = scopeRegistry;
         this.typeCheckScopeRegistry = typeCheckScopeRegistry;
         this.resourceRegistry = resourceRegistry;
@@ -9779,17 +10455,8 @@ class ComponentDecoratorHandler {
         this.jitDeclarationRegistry = jitDeclarationRegistry;
         this.i18nPreserveSignificantWhitespace = i18nPreserveSignificantWhitespace;
         this.strictStandalone = strictStandalone;
-        this.literalCache = new Map();
-        this.elementSchemaRegistry = new checker.DomElementSchemaRegistry();
-        /**
-         * During the asynchronous preanalyze phase, it's necessary to parse the template to extract
-         * any potential <link> tags which might need to be loaded. This cache ensures that work is not
-         * thrown away, and the parsed template is reused during the analyze phase.
-         */
-        this.preanalyzeTemplateCache = new Map();
-        this.preanalyzeStylesCache = new Map();
-        this.precedence = checker.HandlerPrecedence.PRIMARY;
-        this.name = 'ComponentDecoratorHandler';
+        this.enableHmr = enableHmr;
+        this.implicitStandaloneValue = implicitStandaloneValue;
         this.extractTemplateOptions = {
             enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
             i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
@@ -9798,7 +10465,25 @@ class ComponentDecoratorHandler {
             enableLetSyntax: this.enableLetSyntax,
             preserveSignificantWhitespace: this.i18nPreserveSignificantWhitespace,
         };
+        // Dependencies can't be deferred during HMR, because the HMR update module can't have
+        // dynamic imports and its dependencies need to be passed in directly. If dependencies
+        // are deferred, their imports will be deleted so we won't may lose the reference to them.
+        this.canDeferDeps = !enableHmr;
     }
+    literalCache = new Map();
+    elementSchemaRegistry = new checker.DomElementSchemaRegistry();
+    /**
+     * During the asynchronous preanalyze phase, it's necessary to parse the template to extract
+     * any potential <link> tags which might need to be loaded. This cache ensures that work is not
+     * thrown away, and the parsed template is reused during the analyze phase.
+     */
+    preanalyzeTemplateCache = new Map();
+    preanalyzeStylesCache = new Map();
+    /** Whether generated code for a component can defer its dependencies. */
+    canDeferDeps;
+    extractTemplateOptions;
+    precedence = checker.HandlerPrecedence.PRIMARY;
+    name = 'ComponentDecoratorHandler';
     detect(node, decorators) {
         if (!decorators) {
             return undefined;
@@ -9908,7 +10593,7 @@ class ComponentDecoratorHandler {
         let isPoisoned = false;
         // @Component inherits @Directive, so begin by extracting the @Directive metadata and building
         // on it.
-        const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.importTracker, this.evaluator, this.refEmitter, this.referencesRegistry, this.isCore, this.annotateForClosureCompiler, this.compilationMode, this.elementSchemaRegistry.getDefaultComponentElementName(), this.strictStandalone);
+        const directiveResult = 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);
         // `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.
@@ -10200,7 +10885,7 @@ class ComponentDecoratorHandler {
                 classMetadata: this.includeClassMetadata
                     ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorResources(dec, component, styles, template))
                     : null,
-                classDebugInfo: extractClassDebugInfo(node, this.reflector, this.rootDirs, 
+                classDebugInfo: extractClassDebugInfo(node, this.reflector, this.compilerHost, this.rootDirs, 
                 /* forbidOrphanRenderering */ this.forbidOrphanRendering),
                 template,
                 providersRequiringFactory,
@@ -10715,14 +11400,18 @@ class ComponentDecoratorHandler {
         if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
             return [];
         }
-        const perComponentDeferredDeps = this.resolveAllDeferredDependencies(resolution);
+        const perComponentDeferredDeps = this.canDeferDeps
+            ? this.resolveAllDeferredDependencies(resolution)
+            : null;
         const meta = {
             ...analysis.meta,
             ...resolution,
             defer: this.compileDeferBlocks(resolution),
         };
         const fac = compileNgFactoryDefField(checker.toFactoryMetadata(meta, checker.FactoryTarget.Component));
-        removeDeferrableTypesFromComponentDecorator(analysis, perComponentDeferredDeps);
+        if (perComponentDeferredDeps !== null) {
+            removeDeferrableTypesFromComponentDecorator(analysis, perComponentDeferredDeps);
+        }
         const def = checker.compileComponentFromMetadata(meta, pool, checker.makeBindingParser());
         const inputTransformFields = compileInputTransformFields(analysis.inputs);
         const classMetadata = analysis.classMetadata !== null
@@ -10731,8 +11420,14 @@ class ComponentDecoratorHandler {
         const debugInfo = analysis.classDebugInfo !== null
             ? compileClassDebugInfo(analysis.classDebugInfo).toStmt()
             : null;
-        const deferrableImports = this.deferredSymbolTracker.getDeferrableImportDecls();
-        return checker.compileResults(fac, def, classMetadata, 'ɵcmp', inputTransformFields, deferrableImports, debugInfo);
+        const hmrMeta = this.enableHmr
+            ? extractHmrMetatadata(node, this.reflector, this.compilerHost, this.rootDirs, def, fac, classMetadata, debugInfo)
+            : null;
+        const hmrInitializer = hmrMeta ? compileHmrInitializer(hmrMeta).toStmt() : null;
+        const deferrableImports = this.canDeferDeps
+            ? this.deferredSymbolTracker.getDeferrableImportDecls()
+            : null;
+        return checker.compileResults(fac, def, classMetadata, 'ɵcmp', inputTransformFields, deferrableImports, debugInfo, hmrInitializer);
     }
     compilePartial(node, analysis, resolution) {
         if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
@@ -10746,7 +11441,9 @@ class ComponentDecoratorHandler {
                 ? new checker.WrappedNodeExpr(analysis.template.sourceMapping.node)
                 : null,
         };
-        const perComponentDeferredDeps = this.resolveAllDeferredDependencies(resolution);
+        const perComponentDeferredDeps = this.canDeferDeps
+            ? this.resolveAllDeferredDependencies(resolution)
+            : null;
         const meta = {
             ...analysis.meta,
             ...resolution,
@@ -10758,21 +11455,27 @@ class ComponentDecoratorHandler {
         const classMetadata = analysis.classMetadata !== null
             ? compileComponentDeclareClassMetadata(analysis.classMetadata, perComponentDeferredDeps).toStmt()
             : null;
-        const deferrableImports = this.deferredSymbolTracker.getDeferrableImportDecls();
-        return checker.compileResults(fac, def, classMetadata, 'ɵcmp', inputTransformFields, deferrableImports);
+        const hmrMeta = this.enableHmr
+            ? extractHmrMetatadata(node, this.reflector, this.compilerHost, this.rootDirs, def, fac, classMetadata, null)
+            : null;
+        const hmrInitializer = hmrMeta ? compileHmrInitializer(hmrMeta).toStmt() : null;
+        const deferrableImports = this.canDeferDeps
+            ? this.deferredSymbolTracker.getDeferrableImportDecls()
+            : null;
+        return checker.compileResults(fac, def, classMetadata, 'ɵcmp', inputTransformFields, deferrableImports, null, hmrInitializer);
     }
     compileLocal(node, analysis, resolution, pool) {
         // In the local compilation mode we can only rely on the information available
         // within the `@Component.deferredImports` array, because in this mode compiler
         // doesn't have information on which dependencies belong to which defer blocks.
-        const deferrableTypes = analysis.explicitlyDeferredTypes;
+        const deferrableTypes = this.canDeferDeps ? analysis.explicitlyDeferredTypes : null;
         const meta = {
             ...analysis.meta,
             ...resolution,
             defer: this.compileDeferBlocks(resolution),
         };
-        if (analysis.explicitlyDeferredTypes !== null) {
-            removeDeferrableTypesFromComponentDecorator(analysis, analysis.explicitlyDeferredTypes);
+        if (deferrableTypes !== null) {
+            removeDeferrableTypesFromComponentDecorator(analysis, deferrableTypes);
         }
         const fac = compileNgFactoryDefField(checker.toFactoryMetadata(meta, checker.FactoryTarget.Component));
         const def = checker.compileComponentFromMetadata(meta, pool, checker.makeBindingParser());
@@ -10783,8 +11486,41 @@ class ComponentDecoratorHandler {
         const debugInfo = analysis.classDebugInfo !== null
             ? compileClassDebugInfo(analysis.classDebugInfo).toStmt()
             : null;
-        const deferrableImports = this.deferredSymbolTracker.getDeferrableImportDecls();
-        return checker.compileResults(fac, def, classMetadata, 'ɵcmp', inputTransformFields, deferrableImports, debugInfo);
+        const hmrMeta = this.enableHmr
+            ? extractHmrMetatadata(node, this.reflector, this.compilerHost, this.rootDirs, def, fac, classMetadata, debugInfo)
+            : null;
+        const hmrInitializer = hmrMeta ? compileHmrInitializer(hmrMeta).toStmt() : null;
+        const deferrableImports = this.canDeferDeps
+            ? this.deferredSymbolTracker.getDeferrableImportDecls()
+            : null;
+        return checker.compileResults(fac, def, classMetadata, 'ɵcmp', inputTransformFields, deferrableImports, debugInfo, hmrInitializer);
+    }
+    compileHmrUpdateDeclaration(node, analysis, resolution) {
+        if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
+            return null;
+        }
+        // Create a brand-new constant pool since there shouldn't be any constant sharing.
+        const pool = new checker.ConstantPool();
+        const meta = {
+            ...analysis.meta,
+            ...resolution,
+            defer: this.compileDeferBlocks(resolution),
+        };
+        const fac = compileNgFactoryDefField(checker.toFactoryMetadata(meta, checker.FactoryTarget.Component));
+        const def = checker.compileComponentFromMetadata(meta, pool, checker.makeBindingParser());
+        const classMetadata = analysis.classMetadata !== null
+            ? compileComponentClassMetadata(analysis.classMetadata, null).toStmt()
+            : null;
+        const debugInfo = analysis.classDebugInfo !== null
+            ? compileClassDebugInfo(analysis.classDebugInfo).toStmt()
+            : null;
+        const hmrMeta = this.enableHmr
+            ? extractHmrMetatadata(node, this.reflector, this.compilerHost, this.rootDirs, def, fac, classMetadata, debugInfo)
+            : null;
+        const res = checker.compileResults(fac, def, classMetadata, 'ɵcmp', null, null, debugInfo, null);
+        return hmrMeta === null || res.length === 0
+            ? null
+            : getHmrUpdateDeclaration(res, pool.statements, hmrMeta, node.getSourceFile());
     }
     /**
      * Locates defer blocks in case scope information is not available.
@@ -11110,6 +11846,15 @@ function isDefaultImport(node) {
  * Adapts the `compileInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
  */
 class InjectableDecoratorHandler {
+    reflector;
+    evaluator;
+    isCore;
+    strictCtorDeps;
+    injectableRegistry;
+    perf;
+    includeClassMetadata;
+    compilationMode;
+    errorOnDuplicateProv;
     constructor(reflector, evaluator, isCore, strictCtorDeps, injectableRegistry, perf, includeClassMetadata, compilationMode, 
     /**
      * What to do if the injectable already contains a ɵprov property.
@@ -11127,9 +11872,9 @@ class InjectableDecoratorHandler {
         this.includeClassMetadata = includeClassMetadata;
         this.compilationMode = compilationMode;
         this.errorOnDuplicateProv = errorOnDuplicateProv;
-        this.precedence = checker.HandlerPrecedence.SHARED;
-        this.name = 'InjectableDecoratorHandler';
     }
+    precedence = checker.HandlerPrecedence.SHARED;
+    name = 'InjectableDecoratorHandler';
     detect(node, decorators) {
         if (!decorators) {
             return undefined;
@@ -11397,6 +12142,7 @@ function getDep(dep, reflector) {
  * Represents an Angular pipe.
  */
 class PipeSymbol extends SemanticSymbol {
+    name;
     constructor(decl, name) {
         super(decl);
         this.name = name;
@@ -11412,7 +12158,19 @@ class PipeSymbol extends SemanticSymbol {
     }
 }
 class PipeDecoratorHandler {
-    constructor(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, perf, includeClassMetadata, compilationMode, generateExtraImportsInLocalMode, strictStandalone) {
+    reflector;
+    evaluator;
+    metaRegistry;
+    scopeRegistry;
+    injectableRegistry;
+    isCore;
+    perf;
+    includeClassMetadata;
+    compilationMode;
+    generateExtraImportsInLocalMode;
+    strictStandalone;
+    implicitStandaloneValue;
+    constructor(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, perf, includeClassMetadata, compilationMode, generateExtraImportsInLocalMode, strictStandalone, implicitStandaloneValue) {
         this.reflector = reflector;
         this.evaluator = evaluator;
         this.metaRegistry = metaRegistry;
@@ -11424,9 +12182,10 @@ class PipeDecoratorHandler {
         this.compilationMode = compilationMode;
         this.generateExtraImportsInLocalMode = generateExtraImportsInLocalMode;
         this.strictStandalone = strictStandalone;
-        this.precedence = checker.HandlerPrecedence.PRIMARY;
-        this.name = 'PipeDecoratorHandler';
+        this.implicitStandaloneValue = implicitStandaloneValue;
     }
+    precedence = checker.HandlerPrecedence.PRIMARY;
+    name = 'PipeDecoratorHandler';
     detect(node, decorators) {
         if (!decorators) {
             return undefined;
@@ -11475,7 +12234,7 @@ class PipeDecoratorHandler {
             }
             pure = pureValue;
         }
-        let isStandalone = false;
+        let isStandalone = this.implicitStandaloneValue;
         if (pipe.has('standalone')) {
             const expr = pipe.get('standalone');
             const resolved = this.evaluator.evaluate(expr);
@@ -12356,12 +13115,7 @@ function i18nSerialize(bundle, formatName, options) {
     let serializer;
     switch (format) {
         case 'xmb':
-            serializer = new checker.Xmb(
-            // Whenever we disable whitespace preservation, we also want to stop preserving
-            // placeholders because they contain whitespace we want to drop too. Whitespace
-            // inside `{{ name }}` should be ignored for the same reasons as whitespace
-            // outside placeholders.
-            /* preservePlaceholders */ options.i18nPreserveWhitespaceForLegacyExtraction);
+            serializer = new checker.Xmb();
             break;
         case 'xliff2':
         case 'xlf2':
@@ -12494,15 +13248,16 @@ function verifySupportedTypeScriptVersion() {
  * Analyzes a `ts.Program` for cycles.
  */
 class CycleAnalyzer {
+    importGraph;
+    /**
+     * Cycle detection is requested with the same `from` source file for all used directives and pipes
+     * within a component, which makes it beneficial to cache the results as long as the `from` source
+     * file has not changed. This avoids visiting the import graph that is reachable from multiple
+     * directives/pipes more than once.
+     */
+    cachedResults = null;
     constructor(importGraph) {
         this.importGraph = importGraph;
-        /**
-         * Cycle detection is requested with the same `from` source file for all used directives and pipes
-         * within a component, which makes it beneficial to cache the results as long as the `from` source
-         * file has not changed. This avoids visiting the import graph that is reachable from multiple
-         * directives/pipes more than once.
-         */
-        this.cachedResults = null;
     }
     /**
      * Check for a cycle to be created in the `ts.Program` by adding an import between `from` and
@@ -12539,11 +13294,13 @@ const NgCyclicResult = Symbol('NgCyclicResult');
  * on the source file) as earlier executions.
  */
 class CycleResults {
+    from;
+    importGraph;
+    cyclic = {};
+    acyclic = {};
     constructor(from, importGraph) {
         this.from = from;
         this.importGraph = importGraph;
-        this.cyclic = {};
-        this.acyclic = {};
     }
     wouldBeCyclic(sf) {
         const cached = this.getCachedResult(sf);
@@ -12600,6 +13357,9 @@ class CycleResults {
  * needed.
  */
 class Cycle {
+    importGraph;
+    from;
+    to;
     constructor(importGraph, from, to) {
         this.importGraph = importGraph;
         this.from = from;
@@ -12623,10 +13383,12 @@ class Cycle {
  * dependencies within the same program are tracked; imports into packages on NPM are not.
  */
 class ImportGraph {
+    checker;
+    perf;
+    imports = new Map();
     constructor(checker, perf) {
         this.checker = checker;
         this.perf = perf;
-        this.imports = new Map();
     }
     /**
      * List the direct (not transitive) imports of a given `ts.SourceFile`.
@@ -12735,6 +13497,8 @@ function isTypeOnlyImportClause(node) {
  * `getPath()` above.
  */
 class Found {
+    sourceFile;
+    parent;
     constructor(sourceFile, parent) {
         this.sourceFile = sourceFile;
         this.parent = parent;
@@ -12889,6 +13653,9 @@ function extractResolvedTypeString(node, checker) {
 }
 
 class FunctionExtractor {
+    name;
+    exportDeclaration;
+    typeChecker;
     constructor(name, exportDeclaration, typeChecker) {
         this.name = name;
         this.exportDeclaration = exportDeclaration;
@@ -13000,6 +13767,8 @@ function hasLeadingInternalComment(member) {
 
 /** Extractor to pull info for API reference documentation for a TypeScript class or interface. */
 class ClassExtractor {
+    declaration;
+    typeChecker;
     constructor(declaration, typeChecker) {
         this.declaration = declaration;
         this.typeChecker = typeChecker;
@@ -13162,9 +13931,22 @@ class ClassExtractor {
     }
     /** The result only contains properties, method implementations and abstracts */
     filterMethodOverloads(declarations) {
-        return declarations.filter((declaration) => {
+        return declarations.filter((declaration, index) => {
             if (ts__default["default"].isFunctionDeclaration(declaration) || ts__default["default"].isMethodDeclaration(declaration)) {
-                return (!!declaration.body || ts__default["default"].getCombinedModifierFlags(declaration) & ts__default["default"].ModifierFlags.Abstract);
+                if (ts__default["default"].getCombinedModifierFlags(declaration) & ts__default["default"].ModifierFlags.Abstract) {
+                    // TS enforces that all declarations of an abstract method are consecutive
+                    const previousDeclaration = declarations[index - 1];
+                    const samePreviousAbstractMethod = previousDeclaration &&
+                        ts__default["default"].isMethodDeclaration(previousDeclaration) &&
+                        ts__default["default"].getCombinedModifierFlags(previousDeclaration) & ts__default["default"].ModifierFlags.Abstract &&
+                        previousDeclaration.name.getText() === declaration.name?.getText();
+                    // We just need a reference to one member
+                    // In the case of Abstract Methods we only want to return the first abstract.
+                    // Others with the same name are considered as overloads
+                    // Later on, the function extractor will handle overloads and implementation detection
+                    return !samePreviousAbstractMethod;
+                }
+                return !!declaration.body;
             }
             return true;
         });
@@ -13259,6 +14041,8 @@ class ClassExtractor {
 }
 /** Extractor to pull info for API reference documentation for an Angular directive. */
 class DirectiveExtractor extends ClassExtractor {
+    reference;
+    metadata;
     constructor(declaration, reference, metadata, checker) {
         super(declaration, checker);
         this.reference = reference;
@@ -13303,6 +14087,8 @@ class DirectiveExtractor extends ClassExtractor {
 }
 /** Extractor to pull info for API reference documentation for an Angular pipe. */
 class PipeExtractor extends ClassExtractor {
+    reference;
+    metadata;
     constructor(declaration, reference, metadata, typeChecker) {
         super(declaration, typeChecker);
         this.reference = reference;
@@ -13319,6 +14105,8 @@ class PipeExtractor extends ClassExtractor {
 }
 /** Extractor to pull info for API reference documentation for an Angular pipe. */
 class NgModuleExtractor extends ClassExtractor {
+    reference;
+    metadata;
     constructor(declaration, reference, metadata, typeChecker) {
         super(declaration, typeChecker);
         this.reference = reference;
@@ -13770,6 +14558,8 @@ function getImportedSymbols(sourceFile) {
  * public API documentation.
  */
 class DocsExtractor {
+    typeChecker;
+    metadataReader;
     constructor(typeChecker, metadataReader) {
         this.typeChecker = typeChecker;
         this.metadataReader = metadataReader;
@@ -13903,10 +14693,13 @@ function getRelativeFilePath(sourceFile, rootDir) {
 
 /// <reference types="node" />
 class FlatIndexGenerator {
+    entryPoint;
+    moduleName;
+    flatIndexPath;
+    shouldEmit = true;
     constructor(entryPoint, relativeFlatIndexPath, moduleName) {
         this.entryPoint = entryPoint;
         this.moduleName = moduleName;
-        this.shouldEmit = true;
         this.flatIndexPath =
             checker.join(checker.dirname(entryPoint), relativeFlatIndexPath).replace(/\.js$/, '') + '.ts';
     }
@@ -14074,9 +14867,7 @@ function getDescriptorOfDeclaration(decl) {
 }
 
 class ReferenceGraph {
-    constructor() {
-        this.references = new Map();
-    }
+    references = new Map();
     add(from, to) {
         if (!this.references.has(from)) {
             this.references.set(from, new Set());
@@ -14152,9 +14943,7 @@ class ReferenceGraph {
  * 3. One of its resource dependencies has physically changed.
  */
 class FileDependencyGraph {
-    constructor() {
-        this.nodes = new Map();
-    }
+    nodes = new Map();
     addDependency(from, on) {
         this.nodeFor(from).dependsOn.add(checker.absoluteFromSourceFile(on));
     }
@@ -14272,6 +15061,17 @@ var PhaseKind;
  * future one.
  */
 class IncrementalCompilation {
+    depGraph;
+    versions;
+    step;
+    phase;
+    /**
+     * `IncrementalState` of this compilation if it were to be reused in a subsequent incremental
+     * compilation at the current moment.
+     *
+     * Exposed via the `state` read-only getter.
+     */
+    _state;
     constructor(state, depGraph, versions, step) {
         this.depGraph = depGraph;
         this.versions = versions;
@@ -14550,10 +15350,8 @@ function toOriginalSourceFile(sf) {
  * Tracks an `IncrementalState` within the strategy itself.
  */
 class TrackedIncrementalBuildStrategy {
-    constructor() {
-        this.state = null;
-        this.isSet = false;
-    }
+    state = null;
+    isSet = false;
     getIncrementalState() {
         return this.state;
     }
@@ -14587,6 +15385,8 @@ var IdentifierKind;
  * Describes the absolute byte offsets of a text anchor in a source code.
  */
 class AbsoluteSourceSpan {
+    start;
+    end;
     constructor(start, end) {
         this.start = start;
         this.end = end;
@@ -14600,9 +15400,7 @@ class AbsoluteSourceSpan {
  * `DecoratorHandler`s and exposes them to be indexed.
  */
 class IndexingContext {
-    constructor() {
-        this.components = new Set();
-    }
+    components = new Set();
     /**
      * Adds a component to the context.
      */
@@ -14620,15 +15418,19 @@ class IndexingContext {
  * Visiting `text {{prop}}` will return
  * `[TopLevelIdentifier {name: 'prop', span: {start: 7, end: 11}}]`.
  */
-class ExpressionVisitor extends checker.RecursiveAstVisitor {
+class ExpressionVisitor extends checker.RecursiveAstVisitor$1 {
+    expressionStr;
+    absoluteOffset;
+    boundTemplate;
+    targetToIdentifier;
+    identifiers = [];
+    errors = [];
     constructor(expressionStr, absoluteOffset, boundTemplate, targetToIdentifier) {
         super();
         this.expressionStr = expressionStr;
         this.absoluteOffset = absoluteOffset;
         this.boundTemplate = boundTemplate;
         this.targetToIdentifier = targetToIdentifier;
-        this.identifiers = [];
-        this.errors = [];
     }
     /**
      * Returns identifiers discovered in an expression.
@@ -14702,6 +15504,14 @@ class ExpressionVisitor extends checker.RecursiveAstVisitor {
  * identifiers of interest, deferring to an `ExpressionVisitor` as needed.
  */
 class TemplateVisitor$1 extends checker.RecursiveVisitor$1 {
+    boundTemplate;
+    // Identifiers of interest found in the template.
+    identifiers = new Set();
+    errors = [];
+    // Map of targets in a template to their identifiers.
+    targetIdentifierCache = new Map();
+    // Map of elements and templates to their identifiers.
+    elementAndTemplateIdentifierCache = 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.
@@ -14711,13 +15521,6 @@ class TemplateVisitor$1 extends checker.RecursiveVisitor$1 {
     constructor(boundTemplate) {
         super();
         this.boundTemplate = boundTemplate;
-        // Identifiers of interest found in the template.
-        this.identifiers = new Set();
-        this.errors = [];
-        // Map of targets in a template to their identifiers.
-        this.targetIdentifierCache = new Map();
-        // Map of elements and templates to their identifiers.
-        this.elementAndTemplateIdentifierCache = new Map();
     }
     /**
      * Visits a node in the template.
@@ -15043,17 +15846,19 @@ function generateAnalysis(context) {
  * An index of all NgModules that export or re-export a given trait.
  */
 class NgModuleIndexImpl {
+    metaReader;
+    localReader;
     constructor(metaReader, localReader) {
         this.metaReader = metaReader;
         this.localReader = localReader;
-        // A map from an NgModule's Class Declaration to the "main" reference to that module, aka the one
-        // present in the reader metadata object
-        this.ngModuleAuthoritativeReference = new Map();
-        // A map from a Directive/Pipe's class declaration to the class declarations of all re-exporting
-        // NgModules
-        this.typeToExportingModules = new Map();
-        this.indexed = false;
     }
+    // A map from an NgModule's Class Declaration to the "main" reference to that module, aka the one
+    // present in the reader metadata object
+    ngModuleAuthoritativeReference = new Map();
+    // A map from a Directive/Pipe's class declaration to the class declarations of all re-exporting
+    // NgModules
+    typeToExportingModules = new Map();
+    indexed = false;
     updateWith(cache, key, elem) {
         if (cache.has(key)) {
             cache.get(key).add(elem);
@@ -15146,11 +15951,16 @@ const RESOURCE_MARKER_TS = RESOURCE_MARKER + '.ts';
  * `ResourceLoader` which delegates to an `NgCompilerAdapter`'s resource loading methods.
  */
 class AdapterResourceLoader {
+    adapter;
+    options;
+    cache = new Map();
+    fetching = new Map();
+    lookupResolutionHost;
+    canPreload;
+    canPreprocess;
     constructor(adapter, options) {
         this.adapter = adapter;
         this.options = options;
-        this.cache = new Map();
-        this.fetching = new Map();
         this.lookupResolutionHost = createLookupResolutionHost(this.adapter);
         this.canPreload = !!this.adapter.readResource;
         this.canPreprocess = !!this.adapter.transformResource;
@@ -15382,11 +16192,14 @@ function createLookupResolutionHost(adapter) {
  * scopes where necessary.
  */
 class StandaloneComponentScopeReader {
+    metaReader;
+    localModuleReader;
+    dtsModuleReader;
+    cache = new Map();
     constructor(metaReader, localModuleReader, dtsModuleReader) {
         this.metaReader = metaReader;
         this.localModuleReader = localModuleReader;
         this.dtsModuleReader = dtsModuleReader;
-        this.cache = new Map();
     }
     getScopeForComponent(clazz) {
         if (!this.cache.has(clazz)) {
@@ -15522,18 +16335,16 @@ function isSignalSymbol(symbol) {
  * This abstract class provides a base implementation for the run method.
  */
 class TemplateCheckWithVisitor {
-    constructor() {
-        /**
-         * When extended diagnostics were first introduced, the visitor wasn't implemented correctly
-         * which meant that it wasn't visiting the `templateAttrs` of structural directives (e.g.
-         * the expression of `*ngIf`). Fixing the issue causes a lot of internal breakages and will likely
-         * need to be done in a major version to avoid external breakages. This flag is used to opt out
-         * pre-existing diagnostics from the correct behavior until the breakages have been fixed while
-         * ensuring that newly-written diagnostics are correct from the beginning.
-         * TODO(crisbeto): remove this flag and fix the internal brekages.
-         */
-        this.canVisitStructuralAttributes = true;
-    }
+    /**
+     * When extended diagnostics were first introduced, the visitor wasn't implemented correctly
+     * which meant that it wasn't visiting the `templateAttrs` of structural directives (e.g.
+     * the expression of `*ngIf`). Fixing the issue causes a lot of internal breakages and will likely
+     * need to be done in a major version to avoid external breakages. This flag is used to opt out
+     * pre-existing diagnostics from the correct behavior until the breakages have been fixed while
+     * ensuring that newly-written diagnostics are correct from the beginning.
+     * TODO(crisbeto): remove this flag and fix the internal brekages.
+     */
+    canVisitStructuralAttributes = true;
     /**
      * Base implementation for run function, visits all nodes in template and calls
      * `visitNode()` for each one.
@@ -15546,13 +16357,16 @@ 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.RecursiveAstVisitor$1 {
+    ctx;
+    component;
+    check;
+    diagnostics = [];
     constructor(ctx, component, check) {
         super();
         this.ctx = ctx;
         this.component = component;
         this.check = check;
-        this.diagnostics = [];
     }
     visit(node, context) {
         this.diagnostics.push(...this.check.visitNode(this.ctx, this.component, node));
@@ -15680,10 +16494,7 @@ const FUNCTION_INSTANCE_PROPERTIES = new Set(['name', 'length', 'prototype']);
  * Ensures Signals are invoked when used in template interpolations.
  */
 class InterpolatedSignalCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.INTERPOLATED_SIGNAL_NOT_INVOKED;
-    }
+    code = checker.ErrorCode.INTERPOLATED_SIGNAL_NOT_INVOKED;
     visitNode(ctx, component, node) {
         // interpolations like `{{ mySignal }}`
         if (node instanceof checker.Interpolation) {
@@ -15763,10 +16574,7 @@ const factory$9 = {
  * Will return diagnostic information when "([])" is found.
  */
 class InvalidBananaInBoxCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.INVALID_BANANA_IN_BOX;
-    }
+    code = checker.ErrorCode.INVALID_BANANA_IN_BOX;
     visitNode(ctx, component, node) {
         if (!(node instanceof checker.BoundEvent))
             return [];
@@ -15811,10 +16619,7 @@ const KNOWN_CONTROL_FLOW_DIRECTIVES = new Map([
  * hard error instead of a warning.
  */
 class MissingControlFlowDirectiveCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.MISSING_CONTROL_FLOW_DIRECTIVE;
-    }
+    code = checker.ErrorCode.MISSING_CONTROL_FLOW_DIRECTIVE;
     run(ctx, component, template) {
         const componentMetadata = ctx.templateTypeChecker.getDirectiveMetadata(component);
         // Avoid running this check for non-standalone components.
@@ -15857,10 +16662,7 @@ const factory$7 = {
  * Will return diagnostic information when `let` is missing.
  */
 class MissingNgForOfLetCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.MISSING_NGFOROF_LET;
-    }
+    code = checker.ErrorCode.MISSING_NGFOROF_LET;
     visitNode(ctx, component, node) {
         if (!(node instanceof checker.Template)) {
             return [];
@@ -15893,11 +16695,8 @@ const factory$6 = {
  * otherwise it would produce inaccurate results.
  */
 class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.canVisitStructuralAttributes = false;
-        this.code = checker.ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
-    }
+    canVisitStructuralAttributes = false;
+    code = checker.ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
     visitNode(ctx, component, node) {
         if (!(node instanceof checker.Binary) || node.operation !== '??')
             return [];
@@ -15948,11 +16747,8 @@ const factory$5 = {
  * otherwise it would produce inaccurate results.
  */
 class OptionalChainNotNullableCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.canVisitStructuralAttributes = false;
-        this.code = checker.ErrorCode.OPTIONAL_CHAIN_NOT_NULLABLE;
-    }
+    canVisitStructuralAttributes = false;
+    code = checker.ErrorCode.OPTIONAL_CHAIN_NOT_NULLABLE;
     visitNode(ctx, component, node) {
         if (!(node instanceof checker.SafeCall) &&
             !(node instanceof checker.SafePropertyRead) &&
@@ -16007,10 +16803,7 @@ const STYLE_SUFFIXES = ['px', '%', 'em'];
  * binding. These suffixes are only available for style bindings.
  */
 class SuffixNotSupportedCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.SUFFIX_NOT_SUPPORTED;
-    }
+    code = checker.ErrorCode.SUFFIX_NOT_SUPPORTED;
     visitNode(ctx, component, node) {
         if (!(node instanceof checker.BoundAttribute))
             return [];
@@ -16036,10 +16829,7 @@ const factory$3 = {
  * to 'my-id'.
  */
 class TextAttributeNotBindingSpec extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.TEXT_ATTRIBUTE_NOT_BINDING;
-    }
+    code = checker.ErrorCode.TEXT_ATTRIBUTE_NOT_BINDING;
     visitNode(ctx, component, node) {
         if (!(node instanceof checker.TextAttribute))
             return [];
@@ -16082,10 +16872,7 @@ const factory$2 = {
  * This is likely not the intent of the developer. Instead, the intent is likely to call `myFunc`.
  */
 class UninvokedFunctionInEventBindingSpec extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.UNINVOKED_FUNCTION_IN_EVENT_BINDING;
-    }
+    code = checker.ErrorCode.UNINVOKED_FUNCTION_IN_EVENT_BINDING;
     visitNode(ctx, component, node) {
         // If the node is not a bound event, skip it.
         if (!(node instanceof checker.BoundEvent))
@@ -16143,11 +16930,8 @@ const factory$1 = {
  * Ensures that all `@let` declarations in a template are used.
  */
 class UnusedLetDeclarationCheck extends TemplateCheckWithVisitor {
-    constructor() {
-        super(...arguments);
-        this.code = checker.ErrorCode.UNUSED_LET_DECLARATION;
-        this.analysis = new Map();
-    }
+    code = checker.ErrorCode.UNUSED_LET_DECLARATION;
+    analysis = new Map();
     run(ctx, component, template) {
         super.run(ctx, component, template);
         const diagnostics = [];
@@ -16203,6 +16987,8 @@ var DiagnosticCategoryLabel;
 })(DiagnosticCategoryLabel || (DiagnosticCategoryLabel = {}));
 
 class ExtendedTemplateCheckerImpl {
+    partialCtx;
+    templateChecks;
     constructor(templateTypeChecker, typeChecker, templateCheckFactories, options) {
         this.partialCtx = { templateTypeChecker, typeChecker };
         this.templateChecks = new Map();
@@ -16289,6 +17075,7 @@ const SUPPORTED_DIAGNOSTIC_NAMES = new Set([
 ]);
 
 class TemplateSemanticsCheckerImpl {
+    templateTypeChecker;
     constructor(templateTypeChecker) {
         this.templateTypeChecker = templateTypeChecker;
     }
@@ -16301,6 +17088,7 @@ class TemplateSemanticsCheckerImpl {
 }
 /** Visitor that verifies the semantics of a template. */
 class TemplateSemanticsVisitor extends checker.RecursiveVisitor$1 {
+    expressionVisitor;
     constructor(expressionVisitor) {
         super();
         this.expressionVisitor = expressionVisitor;
@@ -16318,7 +17106,10 @@ class TemplateSemanticsVisitor extends checker.RecursiveVisitor$1 {
     }
 }
 /** Visitor that verifies the semantics of the expressions within a template. */
-class ExpressionsSemanticsVisitor extends checker.RecursiveAstVisitor {
+class ExpressionsSemanticsVisitor extends checker.RecursiveAstVisitor$1 {
+    templateTypeChecker;
+    component;
+    diagnostics;
     constructor(templateTypeChecker, component, diagnostics) {
         super();
         this.templateTypeChecker = templateTypeChecker;
@@ -16404,6 +17195,8 @@ const APIS_TO_CHECK = [
  * Rule that flags any initializer APIs that are used outside of an initializer.
  */
 class InitializerApiUsageRule {
+    reflector;
+    importedSymbolsTracker;
     constructor(reflector, importedSymbolsTracker) {
         this.reflector = reflector;
         this.importedSymbolsTracker = importedSymbolsTracker;
@@ -16467,6 +17260,9 @@ class InitializerApiUsageRule {
  * Rule that flags unused symbols inside of the `imports` array of a component.
  */
 class UnusedStandaloneImportsRule {
+    templateTypeChecker;
+    typeCheckingConfig;
+    importedSymbolsTracker;
     constructor(templateTypeChecker, typeCheckingConfig, importedSymbolsTracker) {
         this.templateTypeChecker = templateTypeChecker;
         this.typeCheckingConfig = typeCheckingConfig;
@@ -16503,9 +17299,17 @@ class UnusedStandaloneImportsRule {
             ? ts__default["default"].DiagnosticCategory.Error
             : ts__default["default"].DiagnosticCategory.Warning;
         if (unused.length === metadata.imports.length) {
-            return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, metadata.rawImports, 'All imports are unused', undefined, category);
-        }
-        return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, metadata.rawImports, 'Imports array contains unused imports', unused.map(([ref, type, name]) => checker.makeRelatedInformation(ref.getOriginForDiagnostics(metadata.rawImports), `${type} "${name}" is not used within the template`)), category);
+            return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, this.getDiagnosticNode(metadata.rawImports), 'All imports are unused', undefined, category);
+        }
+        return checker.makeDiagnostic(checker.ErrorCode.UNUSED_STANDALONE_IMPORTS, this.getDiagnosticNode(metadata.rawImports), 'Imports array contains unused imports', unused.map((ref) => {
+            return checker.makeRelatedInformation(
+            // Intentionally don't pass a message to `makeRelatedInformation` to make the diagnostic
+            // less noisy. The node will already be highlighted so the user can see which node is
+            // unused. Note that in the case where an origin can't be resolved, we fall back to
+            // the original node's identifier so the user can still see the name. This can happen
+            // when the unused is coming from an imports array within the same file.
+            ref.getOriginForDiagnostics(metadata.rawImports, ref.node.name), '');
+        }), category);
     }
     getUnusedSymbols(metadata, usedDirectives, usedPipes) {
         const { imports, rawImports } = metadata;
@@ -16521,7 +17325,7 @@ class UnusedStandaloneImportsRule {
                     !usedDirectives.has(currentNode) &&
                     !this.isPotentialSharedReference(current, rawImports)) {
                     unused ??= [];
-                    unused.push([current, dirMeta.isComponent ? 'Component' : 'Directive', dirMeta.name]);
+                    unused.push(current);
                 }
                 continue;
             }
@@ -16531,7 +17335,7 @@ class UnusedStandaloneImportsRule {
                 !usedPipes.has(pipeMeta.name) &&
                 !this.isPotentialSharedReference(current, rawImports)) {
                 unused ??= [];
-                unused.push([current, 'Pipe', pipeMeta.ref.node.name.text]);
+                unused.push(current);
             }
         }
         return unused;
@@ -16563,6 +17367,21 @@ class UnusedStandaloneImportsRule {
         // symbol like an array of shared common components.
         return true;
     }
+    /** Gets the node on which to report the diagnostic. */
+    getDiagnosticNode(importsExpression) {
+        let current = importsExpression.parent;
+        while (current) {
+            // Highlight the `imports:` part of the node instead of the entire node, because
+            // imports arrays can be long which makes the diagnostic harder to scan visually.
+            if (ts__default["default"].isPropertyAssignment(current)) {
+                return current.name;
+            }
+            else {
+                current = current.parent;
+            }
+        }
+        return importsExpression;
+    }
 }
 
 /*!
@@ -16576,6 +17395,7 @@ class UnusedStandaloneImportsRule {
  * Validates that TypeScript files match a specific set of rules set by the Angular compiler.
  */
 class SourceFileValidator {
+    rules;
     constructor(reflector, importedSymbolsTracker, templateTypeChecker, typeCheckingConfig) {
         this.rules = [new InitializerApiUsageRule(reflector, importedSymbolsTracker)];
         {
@@ -19307,7 +20127,7 @@ var semver = /*@__PURE__*/getDefaultExportFromCjs(semverExports);
  * @param minVersion Minimum required version for the feature.
  */
 function coreVersionSupportsFeature(coreVersion, minVersion) {
-    // A version of `19.0.0-next.9` usually means that core is at head so it supports
+    // A version of `19.0.0-rc.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'}`) {
@@ -19381,6 +20201,54 @@ function incrementalFromCompilerTicket(oldCompiler, newProgram, incrementalBuild
  * See the README.md for more information.
  */
 class NgCompiler {
+    adapter;
+    options;
+    inputProgram;
+    programDriver;
+    incrementalStrategy;
+    incrementalCompilation;
+    usePoisonedData;
+    livePerfRecorder;
+    /**
+     * Lazily evaluated state of the compilation.
+     *
+     * This is created on demand by calling `ensureAnalyzed`.
+     */
+    compilation = null;
+    /**
+     * Any diagnostics related to the construction of the compilation.
+     *
+     * These are diagnostics which arose during setup of the host and/or program.
+     */
+    constructionDiagnostics = [];
+    /**
+     * Non-template diagnostics related to the program itself. Does not include template
+     * diagnostics because the template type checker memoizes them itself.
+     *
+     * This is set by (and memoizes) `getNonTemplateDiagnostics`.
+     */
+    nonTemplateDiagnostics = null;
+    closureCompilerEnabled;
+    currentProgram;
+    entryPoint;
+    moduleResolver;
+    resourceManager;
+    cycleAnalyzer;
+    ignoreForDiagnostics;
+    ignoreForEmit;
+    enableTemplateTypeChecker;
+    enableBlockSyntax;
+    enableLetSyntax;
+    angularCoreVersion;
+    enableHmr;
+    implicitStandaloneValue;
+    /**
+     * `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
+     * `NgCompiler` use a `DelegatingPerfRecorder` so the `PerfRecorder` they write to can be updated
+     * with each fresh compilation.
+     */
+    delegatingPerfRecorder;
     /**
      * Convert a `CompilationTicket` into an `NgCompiler` instance for the requested compilation.
      *
@@ -19410,25 +20278,7 @@ class NgCompiler {
         this.incrementalCompilation = incrementalCompilation;
         this.usePoisonedData = usePoisonedData;
         this.livePerfRecorder = livePerfRecorder;
-        /**
-         * Lazily evaluated state of the compilation.
-         *
-         * This is created on demand by calling `ensureAnalyzed`.
-         */
-        this.compilation = null;
-        /**
-         * Any diagnostics related to the construction of the compilation.
-         *
-         * These are diagnostics which arose during setup of the host and/or program.
-         */
-        this.constructionDiagnostics = [];
-        /**
-         * Non-template diagnostics related to the program itself. Does not include template
-         * diagnostics because the template type checker memoizes them itself.
-         *
-         * This is set by (and memoizes) `getNonTemplateDiagnostics`.
-         */
-        this.nonTemplateDiagnostics = null;
+        this.angularCoreVersion = options['_angularCoreVersion'] ?? null;
         this.delegatingPerfRecorder = new DelegatingPerfRecorder(this.perfRecorder);
         this.usePoisonedData = usePoisonedData || !!options._compilePoisonedComponents;
         this.enableTemplateTypeChecker =
@@ -19436,7 +20286,13 @@ class NgCompiler {
         // TODO(crisbeto): remove this flag and base `enableBlockSyntax` on the `angularCoreVersion`.
         this.enableBlockSyntax = options['_enableBlockSyntax'] ?? true;
         this.enableLetSyntax = options['_enableLetSyntax'] ?? true;
-        this.angularCoreVersion = options['_angularCoreVersion'] ?? null;
+        // 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.
+        this.implicitStandaloneValue =
+            this.angularCoreVersion === null ||
+                coreVersionSupportsFeature(this.angularCoreVersion, '>= 19.0.0-0');
+        this.enableHmr = !!options['_enableHmr'];
         this.constructionDiagnostics.push(...this.adapter.constructionDiagnostics, ...verifyCompatibleTypeCheckOptions(this.options));
         this.currentProgram = inputProgram;
         this.closureCompilerEnabled = !!this.options.annotateForClosureCompiler;
@@ -19804,6 +20660,28 @@ class NgCompiler {
         const compilation = this.ensureAnalyzed();
         compilation.traitCompiler.xi18n(ctx);
     }
+    /**
+     * Emits the JavaScript module that can be used to replace the metadata of a class during HMR.
+     * @param node Class for which to generate the update module.
+     */
+    emitHmrUpdateModule(node) {
+        const { traitCompiler, reflector } = this.ensureAnalyzed();
+        if (!reflector.isClass(node)) {
+            return null;
+        }
+        const callback = traitCompiler.compileHmrUpdateCallback(node);
+        if (callback === null) {
+            return null;
+        }
+        const sourceFile = node.getSourceFile();
+        const printer = ts__default["default"].createPrinter();
+        const nodeText = printer.printNode(ts__default["default"].EmitHint.Unspecified, callback, sourceFile);
+        return ts__default["default"].transpileModule(nodeText, {
+            compilerOptions: this.options,
+            fileName: sourceFile.fileName,
+            reportDiagnostics: false,
+        }).outputText;
+    }
     ensureAnalyzed() {
         if (this.compilation === null) {
             this.analyzeSync();
@@ -20182,13 +21060,13 @@ 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, depScopeReader, 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),
+            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),
             // 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, compilationMode, jitDeclarationRegistry, !!this.options.strictStandalone),
+            new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, ngModuleScopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, importTracker, supportTestBed, compilationMode, jitDeclarationRegistry, !!this.options.strictStandalone, this.implicitStandaloneValue),
             // 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),
+            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),
         ];
@@ -20367,6 +21245,7 @@ function makeConfigDiagnostic({ category, code, messageText, }) {
     };
 }
 class ReferenceGraphAdapter {
+    graph;
     constructor(graph) {
         this.graph = graph;
     }
@@ -20384,6 +21263,9 @@ class ReferenceGraphAdapter {
     }
 }
 class NotifyingProgramDriverWrapper {
+    delegate;
+    notifyNewProgram;
+    getSourceFileVersion;
     constructor(delegate, notifyNewProgram) {
         this.delegate = delegate;
         this.notifyNewProgram = notifyNewProgram;
@@ -20424,6 +21306,36 @@ function versionMapFromProgram(program, driver) {
  * generated for this class.
  */
 class DelegatingCompilerHost {
+    delegate;
+    createHash;
+    directoryExists;
+    fileNameToModuleName;
+    getCancellationToken;
+    getCanonicalFileName;
+    getCurrentDirectory;
+    getDefaultLibFileName;
+    getDefaultLibLocation;
+    getDirectories;
+    getEnvironmentVariable;
+    getModifiedResourceFiles;
+    getNewLine;
+    getParsedCommandLine;
+    getSourceFileByPath;
+    readDirectory;
+    readFile;
+    readResource;
+    transformResource;
+    realpath;
+    resolveModuleNames;
+    resolveTypeReferenceDirectives;
+    resourceNameToFileName;
+    trace;
+    useCaseSensitiveFileNames;
+    writeFile;
+    getModuleResolutionCache;
+    hasInvalidatedResolutions;
+    resolveModuleNameLiterals;
+    resolveTypeReferenceDirectiveReferences;
     // jsDocParsingMode is not a method like the other elements above
     // TODO: ignore usage can be dropped once 5.2 support is dropped
     get jsDocParsingMode() {
@@ -20487,11 +21399,16 @@ class DelegatingCompilerHost {
  * `ExtendedTsCompilerHost` methods whenever present.
  */
 class NgCompilerHost extends DelegatingCompilerHost {
+    shimAdapter;
+    shimTagger;
+    entryPoint = null;
+    constructionDiagnostics;
+    inputFiles;
+    rootDirs;
     constructor(delegate, inputFiles, rootDirs, shimAdapter, shimTagger, entryPoint, diagnostics) {
         super(delegate);
         this.shimAdapter = shimAdapter;
         this.shimTagger = shimTagger;
-        this.entryPoint = null;
         this.entryPoint = entryPoint;
         this.constructionDiagnostics = diagnostics;
         this.inputFiles = [...inputFiles, ...shimAdapter.extraInputFiles];
@@ -20636,6 +21553,14 @@ class NgCompilerHost extends DelegatingCompilerHost {
  * command-line main() function or the Angular CLI.
  */
 class NgtscProgram {
+    options;
+    compiler;
+    /**
+     * The primary TypeScript program, which is used for analysis and emit.
+     */
+    tsProgram;
+    host;
+    incrementalStrategy;
     constructor(rootNames, options, delegateHost, oldProgram) {
         this.options = options;
         const perfRecorder = ActivePerfRecorder.zeroedToNow();