@angular/compiler-cli 19.0.0-next.0 → 19.0.0-next.10

package/bundles/{chunk-2SSA4Y5F.js → chunk-Q4DA5WRV.js}

@@ -20,6 +20,7 @@ import {
   entityNameToValue,
   filterToMembersWithDecorator,
   getDefaultImportDeclaration,
+  getProjectRelativePath,
   getSourceFile,
   getSourceFileOrNull,
   getTokenAtPosition,
@@ -45,18 +46,18 @@ import {
   translateStatement,
   translateType,
   typeNodeToValueExpr
-} from "./chunk-WYWH4ABE.js";
+} from "./chunk-O2RMLJTP.js";
 import {
   PerfCheckpoint,
   PerfEvent,
   PerfPhase
-} from "./chunk-ERN7RQQ7.js";
+} from "./chunk-XSNUHRLJ.js";
 import {
   absoluteFrom,
   absoluteFromSourceFile,
   getSourceFileOrError,
   relative
-} from "./chunk-3W345P4E.js";
+} from "./chunk-UJ2J6WV4.js";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/util.mjs
 import { ExternalExpr, ParseLocation, ParseSourceFile, ParseSourceSpan, ReadPropExpr, WrappedNodeExpr } from "@angular/compiler";
@@ -263,7 +264,7 @@ function createSourceSpan(node) {
   const parseSf = new ParseSourceFile(sf.getFullText(), sf.fileName);
   return new ParseSourceSpan(new ParseLocation(parseSf, startOffset, startLine + 1, startCol + 1), new ParseLocation(parseSf, endOffset, endLine + 1, endCol + 1));
 }
-function compileResults(fac, def, metadataStmt, propName, additionalFields, deferrableImports, debugInfo = null) {
+function compileResults(fac, def, metadataStmt, propName, additionalFields, deferrableImports, debugInfo = null, hmrInitializer = null) {
   const statements = def.statements;
   if (metadataStmt !== null) {
     statements.push(metadataStmt);
@@ -271,6 +272,9 @@ function compileResults(fac, def, metadataStmt, propName, additionalFields, defe
   if (debugInfo !== null) {
     statements.push(debugInfo);
   }
+  if (hmrInitializer !== null) {
+    statements.push(hmrInitializer);
+  }
   const results = [
     fac,
     {
@@ -950,11 +954,11 @@ var StaticInterpreter = class {
     }
   }
   visitBindingElement(node, context) {
-    const path2 = [];
+    const path = [];
     let closestDeclaration = node;
     while (ts2.isBindingElement(closestDeclaration) || ts2.isArrayBindingPattern(closestDeclaration) || ts2.isObjectBindingPattern(closestDeclaration)) {
       if (ts2.isBindingElement(closestDeclaration)) {
-        path2.unshift(closestDeclaration);
+        path.unshift(closestDeclaration);
       }
       closestDeclaration = closestDeclaration.parent;
     }
@@ -962,7 +966,7 @@ var StaticInterpreter = class {
       return DynamicValue.fromUnknown(node);
     }
     let value = this.visit(closestDeclaration.initializer, context);
-    for (const element of path2) {
+    for (const element of path) {
       let key;
       if (ts2.isArrayBindingPattern(element.parent)) {
         key = element.parent.elements.indexOf(element);
@@ -1787,6 +1791,7 @@ var DtsMetadataReader = class {
       isSignal,
       inputFieldNamesFromMetadataArray: null,
       imports: null,
+      rawImports: null,
       deferredImports: null,
       schemas: null,
       decorator: null,
@@ -2044,12 +2049,12 @@ var ResourceRegistry = class {
     }
   }
   registerTemplate(templateResource, component) {
-    const { path: path2 } = templateResource;
-    if (path2 !== null) {
-      if (!this.externalTemplateToComponentsMap.has(path2)) {
-        this.externalTemplateToComponentsMap.set(path2, /* @__PURE__ */ new Set());
+    const { path } = templateResource;
+    if (path !== null) {
+      if (!this.externalTemplateToComponentsMap.has(path)) {
+        this.externalTemplateToComponentsMap.set(path, /* @__PURE__ */ new Set());
       }
-      this.externalTemplateToComponentsMap.get(path2).add(component);
+      this.externalTemplateToComponentsMap.get(path).add(component);
     }
     this.componentToTemplateMap.set(component, templateResource);
   }
@@ -2060,15 +2065,15 @@ var ResourceRegistry = class {
     return this.componentToTemplateMap.get(component);
   }
   registerStyle(styleResource, component) {
-    const { path: path2 } = styleResource;
+    const { path } = styleResource;
     if (!this.componentToStylesMap.has(component)) {
       this.componentToStylesMap.set(component, /* @__PURE__ */ new Set());
     }
-    if (path2 !== null) {
-      if (!this.externalStyleToComponentsMap.has(path2)) {
-        this.externalStyleToComponentsMap.set(path2, /* @__PURE__ */ new Set());
+    if (path !== null) {
+      if (!this.externalStyleToComponentsMap.has(path)) {
+        this.externalStyleToComponentsMap.set(path, /* @__PURE__ */ new Set());
       }
-      this.externalStyleToComponentsMap.get(path2).add(component);
+      this.externalStyleToComponentsMap.get(path).add(component);
     }
     this.componentToStylesMap.get(component).add(styleResource);
   }
@@ -2710,6 +2715,19 @@ var TraitCompiler = class {
     this.dtsTransforms.getIvyDeclarationTransform(original.getSourceFile()).addFields(original, res);
     return res.length > 0 ? res : null;
   }
+  compileHmrUpdateCallback(clazz) {
+    const original = ts8.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) {
+      if (trait.state === TraitState.Resolved && trait.handler.compileHmrUpdateDeclaration !== void 0 && !containsErrors(trait.analysisDiagnostics) && !containsErrors(trait.resolveDiagnostics)) {
+        return trait.handler.compileHmrUpdateDeclaration(clazz, trait.analysis, trait.resolution);
+      }
+    }
+    return null;
+  }
   decoratorsFor(node) {
     const original = ts8.getOriginalNode(node);
     if (!this.reflector.isClass(original) || !this.classes.has(original)) {
@@ -3603,13 +3621,12 @@ function removeIdentifierReferences(node, names) {
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/debug_info.mjs
 import { literal as literal2, WrappedNodeExpr as WrappedNodeExpr4 } from "@angular/compiler";
-import * as path from "path";
-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 WrappedNodeExpr4(clazz.name),
     className: literal2(clazz.name.getText()),
@@ -3618,15 +3635,6 @@ function extractClassDebugInfo(clazz, reflection, rootDirs, forbidOrphanRenderin
     forbidOrphanRendering
   };
 }
-function computeRelativePathIfPossible(filePath, rootDirs) {
-  for (const rootDir of rootDirs) {
-    const rel = path.relative(rootDir, filePath);
-    if (!rel.startsWith("..")) {
-      return rel;
-    }
-  }
-  return null;
-}
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/references_registry.mjs
 var NoopReferencesRegistry = class {
@@ -3690,8 +3698,8 @@ var JitDeclarationRegistry = class {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
-import { compileClassDebugInfo, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareComponentFromMetadata, compileDeferResolverFunction, CssSelector as CssSelector4, DEFAULT_INTERPOLATION_CONFIG as DEFAULT_INTERPOLATION_CONFIG2, DomElementSchemaRegistry as DomElementSchemaRegistry3, ExternalExpr as ExternalExpr8, FactoryTarget as FactoryTarget3, makeBindingParser as makeBindingParser2, outputAst as o2, R3TargetBinder, R3TemplateDependencyKind, SelectorMatcher as SelectorMatcher3, ViewEncapsulation as ViewEncapsulation2 } from "@angular/compiler";
-import ts45 from "typescript";
+import { compileClassDebugInfo, compileHmrInitializer, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareComponentFromMetadata, compileDeferResolverFunction, ConstantPool as ConstantPool2, CssSelector as CssSelector4, DEFAULT_INTERPOLATION_CONFIG as DEFAULT_INTERPOLATION_CONFIG2, DomElementSchemaRegistry as DomElementSchemaRegistry3, ExternalExpr as ExternalExpr8, FactoryTarget as FactoryTarget3, makeBindingParser as makeBindingParser2, outputAst as o4, R3TargetBinder, R3TemplateDependencyKind, SelectorMatcher as SelectorMatcher3, ViewEncapsulation as ViewEncapsulation2 } from "@angular/compiler";
+import ts47 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.mjs
 import ts15 from "typescript";
@@ -3740,11 +3748,11 @@ var SemanticDepGraph = class {
     }
     return previousSymbol;
   }
-  getSymbolByName(path2, identifier) {
-    if (!this.files.has(path2)) {
+  getSymbolByName(path, identifier) {
+    if (!this.files.has(path)) {
       return null;
     }
-    const file = this.files.get(path2);
+    const file = this.files.get(path);
     if (!file.has(identifier)) {
       return null;
     }
@@ -4792,6 +4800,9 @@ function parseDescendantsOption(value) {
   throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, value, `Expected "descendants" option to be a boolean literal.`);
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/standalone-default-value.mjs
+var NG_STANDALONE_DEFAULT_VALUE = true;
+
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.mjs
 var EMPTY_OBJECT = {};
 var queryDecoratorNames = [
@@ -4801,7 +4812,7 @@ var queryDecoratorNames = [
   "ContentChildren"
 ];
 var QUERY_TYPES = new Set(queryDecoratorNames);
-function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, evaluator, refEmitter, referencesRegistry, isCore, annotateForClosureCompiler, compilationMode, defaultSelector) {
+function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, evaluator, refEmitter, referencesRegistry, isCore, annotateForClosureCompiler, compilationMode, defaultSelector, strictStandalone) {
   let directive;
   if (decorator.args === null || decorator.args.length === 0) {
     directive = /* @__PURE__ */ new Map();
@@ -4868,7 +4879,7 @@ function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, ev
   const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
   const ctorDeps = selector !== null ? validateConstructorDependencies(clazz, rawCtorDeps) : unwrapConstructorDependencies(rawCtorDeps);
   const isStructural = ctorDeps !== null && ctorDeps !== "invalid" && ctorDeps.some((dep) => dep.token instanceof ExternalExpr4 && dep.token.value.moduleName === "@angular/core" && dep.token.value.name === "TemplateRef");
-  let isStandalone = false;
+  let isStandalone = NG_STANDALONE_DEFAULT_VALUE;
   if (directive.has("standalone")) {
     const expr = directive.get("standalone");
     const resolved = evaluator.evaluate(expr);
@@ -4876,6 +4887,9 @@ function extractDirectiveMetadata(clazz, decorator, reflector, importTracker, ev
       throw createValueHasWrongTypeError(expr, resolved, `standalone flag must be a boolean`);
     }
     isStandalone = resolved;
+    if (!isStandalone && strictStandalone) {
+      throw new FatalDiagnosticError(ErrorCode.NON_STANDALONE_NOT_ALLOWED, expr, `Only standalone components/directives are allowed when 'strictStandalone' is enabled.`);
+    }
   }
   let isSignal = false;
   if (directive.has("signals")) {
@@ -5696,7 +5710,7 @@ var LIFECYCLE_HOOKS = /* @__PURE__ */ new Set([
   "ngAfterContentChecked"
 ]);
 var DirectiveDecoratorHandler = class {
-  constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, annotateForClosureCompiler, perf, importTracker, includeClassMetadata, compilationMode, jitDeclarationRegistry) {
+  constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, annotateForClosureCompiler, perf, importTracker, includeClassMetadata, compilationMode, jitDeclarationRegistry, strictStandalone) {
     this.reflector = reflector;
     this.evaluator = evaluator;
     this.metaRegistry = metaRegistry;
@@ -5714,6 +5728,7 @@ var DirectiveDecoratorHandler = class {
     this.includeClassMetadata = includeClassMetadata;
     this.compilationMode = compilationMode;
     this.jitDeclarationRegistry = jitDeclarationRegistry;
+    this.strictStandalone = strictStandalone;
     this.precedence = HandlerPrecedence.PRIMARY;
     this.name = "DirectiveDecoratorHandler";
   }
@@ -5746,7 +5761,8 @@ var DirectiveDecoratorHandler = class {
       this.isCore,
       this.annotateForClosureCompiler,
       this.compilationMode,
-      null
+      null,
+      this.strictStandalone
     );
     if (directiveResult.jitForced) {
       this.jitDeclarationRegistry.jitDeclarations.add(node);
@@ -5802,6 +5818,7 @@ var DirectiveDecoratorHandler = class {
       isStandalone: analysis.meta.isStandalone,
       isSignal: analysis.meta.isSignal,
       imports: null,
+      rawImports: null,
       deferredImports: null,
       schemas: null,
       ngContentSelectors: null,
@@ -6568,9 +6585,9 @@ function isSyntheticReference(ref) {
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/diagnostics.mjs
 function makeCyclicImportInfo(ref, type, cycle) {
   const name = ref.debugName || "(unknown)";
-  const path2 = cycle.getPath().map((sf) => sf.fileName).join(" -> ");
+  const path = cycle.getPath().map((sf) => sf.fileName).join(" -> ");
   const message = `The ${type} '${name}' is used in the template but importing it would create a cycle: `;
-  return makeRelatedInformation(ref.node, message + path2);
+  return makeRelatedInformation(ref.node, message + path);
 }
 function checkCustomElementSelectorForErrors(selector) {
   if (selector.includes(".") || selector.includes("[") && selector.includes("]")) {
@@ -6674,12 +6691,14 @@ function parseExtractedTemplate(template, sourceStr, sourceParseRange, escapedSt
   };
   const parsedTemplate = parseTemplate(sourceStr, sourceMapUrl != null ? sourceMapUrl : "", {
     ...commonParseOptions,
-    preserveWhitespaces: template.preserveWhitespaces
+    preserveWhitespaces: template.preserveWhitespaces,
+    preserveSignificantWhitespace: options.preserveSignificantWhitespace
   });
   const { nodes: diagNodes } = parseTemplate(sourceStr, sourceMapUrl != null ? sourceMapUrl : "", {
     ...commonParseOptions,
     preserveWhitespaces: true,
     preserveLineEndings: true,
+    preserveSignificantWhitespace: true,
     leadingTriviaChars: []
   });
   return {
@@ -6753,7 +6772,8 @@ function preloadAndParseTemplate(evaluator, resourceLoader, depTracker, preanaly
       const resourceUrl = resourceLoader.resolve(templateUrl, containingFile);
       const templatePromise = resourceLoader.preload(resourceUrl, {
         type: "template",
-        containingFile
+        containingFile,
+        className: node.name.text
       });
       if (templatePromise !== void 0) {
         return templatePromise.then(() => {
@@ -6855,7 +6875,7 @@ function extractComponentStyleUrls(evaluator, component) {
       {
         url: styleUrl,
         source: 2,
-        nodeForError: styleUrlExpr
+        expression: styleUrlExpr
       }
     ];
   }
@@ -6875,7 +6895,7 @@ function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
         styleUrls.push({
           url: styleUrl,
           source: 2,
-          nodeForError: styleUrlExpr
+          expression: styleUrlExpr
         });
       }
     }
@@ -6888,32 +6908,17 @@ function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
       styleUrls.push({
         url: styleUrl,
         source: 2,
-        nodeForError: styleUrlsExpr
+        expression: styleUrlsExpr
       });
     }
   }
   return styleUrls;
 }
-function extractStyleResources(resourceLoader, component, containingFile) {
+function extractInlineStyleResources(component) {
   const styles = /* @__PURE__ */ new Set();
   function stringLiteralElements(array) {
     return array.elements.filter((e) => ts25.isStringLiteralLike(e));
   }
-  const styleUrlExpr = component.get("styleUrl");
-  const styleUrlsExpr = component.get("styleUrls");
-  if (styleUrlsExpr !== void 0 && ts25.isArrayLiteralExpression(styleUrlsExpr)) {
-    for (const expression of stringLiteralElements(styleUrlsExpr)) {
-      const resource = stringLiteralUrlToResource(resourceLoader, expression, containingFile);
-      if (resource !== null) {
-        styles.add(resource);
-      }
-    }
-  } else if (styleUrlExpr !== void 0 && ts25.isStringLiteralLike(styleUrlExpr)) {
-    const resource = stringLiteralUrlToResource(resourceLoader, styleUrlExpr, containingFile);
-    if (resource !== null) {
-      styles.add(resource);
-    }
-  }
   const stylesExpr = component.get("styles");
   if (stylesExpr !== void 0) {
     if (ts25.isArrayLiteralExpression(stylesExpr)) {
@@ -6926,23 +6931,15 @@ function extractStyleResources(resourceLoader, component, containingFile) {
   }
   return styles;
 }
-function stringLiteralUrlToResource(resourceLoader, expression, containingFile) {
-  try {
-    const resourceUrl = resourceLoader.resolve(expression.text, containingFile);
-    return { path: absoluteFrom(resourceUrl), expression };
-  } catch {
-    return null;
-  }
-}
 function _extractTemplateStyleUrls(template) {
   if (template.styleUrls === null) {
     return [];
   }
-  const nodeForError = getTemplateDeclarationNodeForError(template.declaration);
+  const expression = getTemplateDeclarationNodeForError(template.declaration);
   return template.styleUrls.map((url) => ({
     url,
     source: 1,
-    nodeForError
+    expression
   }));
 }
 
@@ -9829,6 +9826,12 @@ var AstTranslator = class {
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
+  visitTypeofExpresion(ast) {
+    const expression = wrapForDiagnostics(this.translate(ast.expression));
+    const node = ts40.factory.createTypeOfExpression(expression);
+    addParseSpanInfo(node, ast.sourceSpan);
+    return node;
+  }
   visitPropertyRead(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
     const name = ts40.factory.createPropertyAccessExpression(receiver, ast.name);
@@ -9979,6 +9982,9 @@ var _VeSafeLhsInferenceBugDetector = class {
   visitPrefixNot(ast) {
     return ast.expression.visit(this);
   }
+  visitTypeofExpresion(ast) {
+    return ast.expression.visit(this);
+  }
   visitNonNullAssert(ast) {
     return ast.expression.visit(this);
   }
@@ -11266,6 +11272,9 @@ var _Scope = class {
   appendDeferredBlock(block) {
     this.appendDeferredTriggers(block, block.triggers);
     this.appendDeferredTriggers(block, block.prefetchTriggers);
+    if (block.hydrateTriggers.when) {
+      this.opQueue.push(new TcbExpressionOp(this.tcb, this, block.hydrateTriggers.when.value));
+    }
     this.appendChildren(block);
     if (block.placeholder !== null) {
       this.appendChildren(block.placeholder);
@@ -11336,7 +11345,7 @@ var TcbExpressionTranslator = class {
     return astToTypescript(ast, (ast2) => this.resolve(ast2), this.tcb.env.config);
   }
   resolve(ast) {
-    if (ast instanceof PropertyRead3 && ast.receiver instanceof ImplicitReceiver2) {
+    if (ast instanceof PropertyRead3 && ast.receiver instanceof ImplicitReceiver2 && !(ast.receiver instanceof ThisReceiver)) {
       const target = this.tcb.boundTarget.getExpressionTarget(ast);
       const targetExpression = target === null ? null : this.getTargetNodeExpression(target, ast);
       if (target instanceof TmplAstLetDeclaration2 && !this.isValidLetDeclarationAccess(target, ast)) {
@@ -11986,7 +11995,7 @@ var TemplateSourceManager = class {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/template_symbol_builder.mjs
-import { AST, ASTWithSource as ASTWithSource2, BindingPipe as BindingPipe2, PropertyRead as PropertyRead4, PropertyWrite as PropertyWrite3, R3Identifiers as R3Identifiers5, SafePropertyRead as SafePropertyRead4, TmplAstBoundAttribute as TmplAstBoundAttribute2, TmplAstBoundEvent, TmplAstElement as TmplAstElement3, TmplAstLetDeclaration as TmplAstLetDeclaration3, TmplAstReference as TmplAstReference3, TmplAstTemplate as TmplAstTemplate2, TmplAstTextAttribute as TmplAstTextAttribute3, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
+import { AST, ASTWithName, ASTWithSource as ASTWithSource2, BindingPipe as BindingPipe2, PropertyRead as PropertyRead4, PropertyWrite as PropertyWrite3, R3Identifiers as R3Identifiers5, SafePropertyRead as SafePropertyRead4, TmplAstBoundAttribute as TmplAstBoundAttribute2, TmplAstBoundEvent, TmplAstElement as TmplAstElement3, TmplAstLetDeclaration as TmplAstLetDeclaration3, TmplAstReference as TmplAstReference3, TmplAstTemplate as TmplAstTemplate2, TmplAstTextAttribute as TmplAstTextAttribute3, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
 import ts44 from "typescript";
 var SymbolBuilder = class {
   constructor(tcbPath, tcbIsShim, typeCheckBlock, templateData, componentScopeReader, getTypeChecker) {
@@ -12466,7 +12475,7 @@ var SymbolBuilder = class {
       return this.getSymbol(expressionTarget);
     }
     let withSpan = expression.sourceSpan;
-    if (expression instanceof PropertyWrite3) {
+    if (expression instanceof PropertyWrite3 || expression instanceof ASTWithName && !(expression instanceof SafePropertyRead4)) {
       withSpan = expression.nameSpan;
     }
     let node = null;
@@ -12508,6 +12517,8 @@ var SymbolBuilder = class {
     let tsSymbol;
     if (ts44.isPropertyAccessExpression(node)) {
       tsSymbol = this.getTypeChecker().getSymbolAtLocation(node.name);
+    } else if (ts44.isCallExpression(node)) {
+      tsSymbol = this.getTypeChecker().getSymbolAtLocation(node.expression);
     } else {
       tsSymbol = this.getTypeChecker().getSymbolAtLocation(node);
     }
@@ -12584,7 +12595,7 @@ var TemplateTypeCheckerImpl = class {
     this.elementTagCache = /* @__PURE__ */ new Map();
     this.isComplete = false;
   }
-  getTemplate(component) {
+  getTemplate(component, optimizeFor) {
     const { data } = this.getLatestComponentState(component);
     if (data === null) {
       return null;
@@ -12599,8 +12610,15 @@ var TemplateTypeCheckerImpl = class {
     var _a;
     return ((_a = this.getLatestComponentState(component).data) == null ? void 0 : _a.boundTarget.getUsedPipes()) || null;
   }
-  getLatestComponentState(component) {
-    this.ensureShimForComponent(component);
+  getLatestComponentState(component, optimizeFor = OptimizeFor.SingleFile) {
+    switch (optimizeFor) {
+      case OptimizeFor.WholeProgram:
+        this.ensureAllShimsForAllFiles();
+        break;
+      case OptimizeFor.SingleFile:
+        this.ensureShimForComponent(component);
+        break;
+    }
     const sf = component.getSourceFile();
     const sfPath = absoluteFromSourceFile(sf);
     const shimPath = TypeCheckShimGenerator.shimFor(sfPath);
@@ -12894,16 +12912,16 @@ var TemplateTypeCheckerImpl = class {
       this.perf.memory(PerfCheckpoint.TtcUpdateProgram);
     });
   }
-  getFileData(path2) {
-    if (!this.state.has(path2)) {
-      this.state.set(path2, {
+  getFileData(path) {
+    if (!this.state.has(path)) {
+      this.state.set(path, {
         hasInlines: false,
         sourceManager: new TemplateSourceManager(),
         isComplete: false,
         shimData: /* @__PURE__ */ new Map()
       });
     }
-    return this.state.get(path2);
+    return this.state.get(path);
   }
   getSymbolOfNode(node, component) {
     const builder = this.getOrCreateSymbolBuilder(component);
@@ -13258,18 +13276,190 @@ var SingleShimTypeCheckingHost = class extends SingleFileTypeCheckingHost {
   }
 };
 
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/hmr/src/metadata.mjs
+import { outputAst as o3 } from "@angular/compiler";
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/hmr/src/extract_locals.mjs
+import { outputAst as o2 } from "@angular/compiler";
+import ts45 from "typescript";
+function extractHmrLocals(node, definition, factory, classMetadata, debugInfo) {
+  var _a;
+  const name = ts45.isClassDeclaration(node) && node.name ? node.name.text : null;
+  const visitor = new PotentialTopLevelReadsVisitor();
+  const sourceFile = node.getSourceFile();
+  definition.expression.visitExpression(visitor, null);
+  definition.statements.forEach((statement) => statement.visitStatement(visitor, null));
+  (_a = factory.initializer) == null ? void 0 : _a.visitExpression(visitor, null);
+  factory.statements.forEach((statement) => statement.visitStatement(visitor, null));
+  classMetadata == null ? void 0 : classMetadata.visitStatement(visitor, null);
+  debugInfo == null ? void 0 : debugInfo.visitStatement(visitor, null);
+  const availableTopLevel = getTopLevelDeclarationNames(sourceFile);
+  return Array.from(visitor.allReads).filter((r) => r !== name && availableTopLevel.has(r));
+}
+function getTopLevelDeclarationNames(sourceFile) {
+  var _a;
+  const results = /* @__PURE__ */ new Set();
+  for (const node of sourceFile.statements) {
+    if (ts45.isClassDeclaration(node) || ts45.isFunctionDeclaration(node) || ts45.isEnumDeclaration(node) && !((_a = node.modifiers) == null ? void 0 : _a.some((m) => m.kind === ts45.SyntaxKind.ConstKeyword))) {
+      if (node.name) {
+        results.add(node.name.text);
+      }
+      continue;
+    }
+    if (ts45.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        trackBindingName(decl.name, results);
+      }
+      continue;
+    }
+    if (ts45.isImportDeclaration(node) && node.importClause) {
+      const importClause = node.importClause;
+      if (importClause.isTypeOnly) {
+        continue;
+      }
+      if (importClause.name) {
+        results.add(importClause.name.text);
+      }
+      if (importClause.namedBindings) {
+        const namedBindings = importClause.namedBindings;
+        if (ts45.isNamespaceImport(namedBindings)) {
+          results.add(namedBindings.name.text);
+        } else {
+          namedBindings.elements.forEach((el) => {
+            if (!el.isTypeOnly) {
+              results.add(el.name.text);
+            }
+          });
+        }
+      }
+      continue;
+    }
+  }
+  return results;
+}
+function trackBindingName(node, results) {
+  if (ts45.isIdentifier(node)) {
+    results.add(node.text);
+  } else {
+    for (const el of node.elements) {
+      if (!ts45.isOmittedExpression(el)) {
+        trackBindingName(el.name, results);
+      }
+    }
+  }
+}
+var PotentialTopLevelReadsVisitor = class extends o2.RecursiveAstVisitor {
+  constructor() {
+    super(...arguments);
+    this.allReads = /* @__PURE__ */ new Set();
+    this.addAllTopLevelIdentifiers = (node) => {
+      if (ts45.isIdentifier(node) && this.isTopLevelIdentifierReference(node)) {
+        this.allReads.add(node.text);
+      } else {
+        ts45.forEachChild(node, this.addAllTopLevelIdentifiers);
+      }
+    };
+  }
+  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);
+  }
+  isTopLevelIdentifierReference(node) {
+    const parent = node.parent;
+    if (!parent) {
+      return false;
+    }
+    if (ts45.isSourceFile(parent) || ts45.isExpressionStatement(parent) && parent.expression === node) {
+      return true;
+    }
+    if (ts45.isCallExpression(parent)) {
+      return parent.expression === node || parent.arguments.includes(node);
+    }
+    if (ts45.isPropertyAccessExpression(parent)) {
+      return parent.expression === node;
+    }
+    if (ts45.isArrayLiteralExpression(parent)) {
+      return parent.elements.includes(node);
+    }
+    if (ts45.isPropertyAssignment(parent)) {
+      return parent.initializer === node;
+    }
+    if (ts45.isClassDeclaration(parent)) {
+      return parent.name === node;
+    }
+    return false;
+  }
+  isTypeScriptNode(value) {
+    return !!value && typeof value.kind === "number";
+  }
+};
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/hmr/src/metadata.mjs
+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 o3.WrappedNodeExpr(clazz.name),
+    className: clazz.name.text,
+    filePath,
+    locals: extractHmrLocals(clazz, definition, factory, classMetadata, debugInfo),
+    coreName: "__ngCore__"
+  };
+  return meta;
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/hmr/src/update_declaration.mjs
+import { compileHmrUpdateCallback } from "@angular/compiler";
+import ts46 from "typescript";
+function getHmrUpdateDeclaration(compilationResults, constantStatements, meta, sourceFile) {
+  const importRewriter = new HmrModuleImportRewriter(meta.coreName);
+  const importManager = new ImportManager({
+    ...presetImportManagerForceNamespaceImports,
+    rewriter: importRewriter
+  });
+  const callback = compileHmrUpdateCallback(compilationResults, constantStatements, meta);
+  const node = translateStatement(sourceFile, callback, importManager);
+  return ts46.factory.updateFunctionDeclaration(node, [
+    ts46.factory.createToken(ts46.SyntaxKind.ExportKeyword),
+    ts46.factory.createToken(ts46.SyntaxKind.DefaultKeyword)
+  ], node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
+}
+var HmrModuleImportRewriter = class {
+  constructor(coreName) {
+    this.coreName = coreName;
+  }
+  rewriteNamespaceImportIdentifier(specifier, moduleName) {
+    return moduleName === "@angular/core" ? this.coreName : specifier;
+  }
+  rewriteSymbol(symbol) {
+    return symbol;
+  }
+  rewriteSpecifier(specifier) {
+    return specifier;
+  }
+};
+
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
 var EMPTY_ARRAY2 = [];
 var isUsedDirective = (decl) => decl.kind === R3TemplateDependencyKind.Directive;
 var isUsedPipe = (decl) => decl.kind === R3TemplateDependencyKind.Pipe;
 var ComponentDecoratorHandler = class {
-  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, localCompilationExtraImportsTracker, jitDeclarationRegistry) {
+  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) {
     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;
@@ -13300,8 +13490,12 @@ var ComponentDecoratorHandler = class {
     this.forbidOrphanRendering = forbidOrphanRendering;
     this.enableBlockSyntax = enableBlockSyntax;
     this.enableLetSyntax = enableLetSyntax;
+    this.externalRuntimeStyles = externalRuntimeStyles;
     this.localCompilationExtraImportsTracker = localCompilationExtraImportsTracker;
     this.jitDeclarationRegistry = jitDeclarationRegistry;
+    this.i18nPreserveSignificantWhitespace = i18nPreserveSignificantWhitespace;
+    this.strictStandalone = strictStandalone;
+    this.enableHmr = enableHmr;
     this.literalCache = /* @__PURE__ */ new Map();
     this.elementSchemaRegistry = new DomElementSchemaRegistry3();
     this.preanalyzeTemplateCache = /* @__PURE__ */ new Map();
@@ -13313,8 +13507,10 @@ var ComponentDecoratorHandler = class {
       i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
       usePoisonedData: this.usePoisonedData,
       enableBlockSyntax: this.enableBlockSyntax,
-      enableLetSyntax: this.enableLetSyntax
+      enableLetSyntax: this.enableLetSyntax,
+      preserveSignificantWhitespace: this.i18nPreserveSignificantWhitespace
     };
+    this.canDeferDeps = !enableHmr;
   }
   detect(node, decorators) {
     if (!decorators) {
@@ -13341,36 +13537,63 @@ var ComponentDecoratorHandler = class {
     const resolveStyleUrl = (styleUrl) => {
       try {
         const resourceUrl = this.resourceLoader.resolve(styleUrl, containingFile);
-        return this.resourceLoader.preload(resourceUrl, { type: "style", containingFile });
+        return this.resourceLoader.preload(resourceUrl, {
+          type: "style",
+          containingFile,
+          className: node.name.text
+        });
       } catch {
         return void 0;
       }
     };
     const templateAndTemplateStyleResources = preloadAndParseTemplate(this.evaluator, this.resourceLoader, this.depTracker, this.preanalyzeTemplateCache, node, decorator, component, containingFile, this.defaultPreserveWhitespaces, this.extractTemplateOptions, this.compilationMode).then((template) => {
       if (template === null) {
-        return void 0;
+        return { templateStyles: [], templateStyleUrls: [] };
+      }
+      let templateUrl;
+      if (template.sourceMapping.type === "external") {
+        templateUrl = template.sourceMapping.templateUrl;
       }
-      return Promise.all(template.styleUrls.map((styleUrl) => resolveStyleUrl(styleUrl))).then(() => void 0);
+      return {
+        templateUrl,
+        templateStyles: template.styles,
+        templateStyleUrls: template.styleUrls
+      };
     });
     const componentStyleUrls = extractComponentStyleUrls(this.evaluator, component);
-    let inlineStyles;
-    if (component.has("styles")) {
-      const litStyles = parseDirectiveStyles(component, this.evaluator, this.compilationMode);
-      if (litStyles === null) {
-        this.preanalyzeStylesCache.set(node, null);
-      } else {
-        inlineStyles = Promise.all(litStyles.map((style) => this.resourceLoader.preprocessInline(style, { type: "style", containingFile }))).then((styles) => {
-          this.preanalyzeStylesCache.set(node, styles);
-        });
+    return templateAndTemplateStyleResources.then(async (templateInfo) => {
+      let styles = null;
+      let orderOffset = 0;
+      const rawStyles = parseDirectiveStyles(component, this.evaluator, this.compilationMode);
+      if (rawStyles == null ? void 0 : rawStyles.length) {
+        styles = await Promise.all(rawStyles.map((style) => this.resourceLoader.preprocessInline(style, {
+          type: "style",
+          containingFile,
+          order: orderOffset++,
+          className: node.name.text
+        })));
+      }
+      if (templateInfo.templateStyles) {
+        styles != null ? styles : styles = [];
+        styles.push(...await Promise.all(templateInfo.templateStyles.map((style) => {
+          var _a;
+          return this.resourceLoader.preprocessInline(style, {
+            type: "style",
+            containingFile: (_a = templateInfo.templateUrl) != null ? _a : containingFile,
+            order: orderOffset++,
+            className: node.name.text
+          });
+        })));
       }
-    } else {
-      this.preanalyzeStylesCache.set(node, null);
-    }
-    return Promise.all([
-      templateAndTemplateStyleResources,
-      inlineStyles,
-      ...componentStyleUrls.map((styleUrl) => resolveStyleUrl(styleUrl.url))
-    ]).then(() => void 0);
+      this.preanalyzeStylesCache.set(node, styles);
+      if (this.externalRuntimeStyles) {
+        return;
+      }
+      await Promise.all([
+        ...componentStyleUrls.map((styleUrl) => resolveStyleUrl(styleUrl.url)),
+        ...templateInfo.templateStyleUrls.map((url) => resolveStyleUrl(url))
+      ]);
+    });
   }
   analyze(node, decorator) {
     var _a, _b, _c, _d, _e;
@@ -13379,7 +13602,7 @@ var ComponentDecoratorHandler = class {
     this.literalCache.delete(decorator);
     let diagnostics;
     let isPoisoned = false;
-    const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.importTracker, this.evaluator, this.refEmitter, this.referencesRegistry, this.isCore, this.annotateForClosureCompiler, this.compilationMode, this.elementSchemaRegistry.getDefaultComponentElementName());
+    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);
     if (directiveResult.jitForced) {
       this.jitDeclarationRegistry.jitDeclarations.add(node);
       return {};
@@ -13390,13 +13613,13 @@ var ComponentDecoratorHandler = class {
     if (this.compilationMode !== CompilationMode.LOCAL) {
       changeDetection = resolveEnumValue(this.evaluator, component, "changeDetection", "ChangeDetectionStrategy");
     } else if (component.has("changeDetection")) {
-      changeDetection = new o2.WrappedNodeExpr(component.get("changeDetection"));
+      changeDetection = new o4.WrappedNodeExpr(component.get("changeDetection"));
     }
     let animations = null;
     let animationTriggerNames = null;
     if (component.has("animations")) {
       const animationExpression = component.get("animations");
-      animations = new o2.WrappedNodeExpr(animationExpression);
+      animations = new o4.WrappedNodeExpr(animationExpression);
       const animationsValue = this.evaluator.evaluate(animationExpression, animationTriggerResolver);
       animationTriggerNames = { includesDynamicAnimations: false, staticTriggerNames: [] };
       collectAnimationNames(animationsValue, animationTriggerNames);
@@ -13415,7 +13638,7 @@ var ComponentDecoratorHandler = class {
     if (component.has("viewProviders")) {
       const viewProviders = component.get("viewProviders");
       viewProvidersRequiringFactory = resolveProvidersRequiringFactory(viewProviders, this.reflector, this.evaluator);
-      wrappedViewProviders = new o2.WrappedNodeExpr(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(viewProviders) : viewProviders);
+      wrappedViewProviders = new o4.WrappedNodeExpr(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(viewProviders) : viewProviders);
     }
     if (component.has("providers")) {
       providersRequiringFactory = resolveProvidersRequiringFactory(component.get("providers"), this.reflector, this.evaluator);
@@ -13486,7 +13709,8 @@ var ComponentDecoratorHandler = class {
         i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
         usePoisonedData: this.usePoisonedData,
         enableBlockSyntax: this.enableBlockSyntax,
-        enableLetSyntax: this.enableLetSyntax
+        enableLetSyntax: this.enableLetSyntax,
+        preserveSignificantWhitespace: this.i18nPreserveSignificantWhitespace
       }, this.compilationMode);
       if (this.compilationMode === CompilationMode.LOCAL && template.errors && template.errors.length > 0) {
         if (diagnostics === void 0) {
@@ -13504,7 +13728,8 @@ var ComponentDecoratorHandler = class {
       expression: template.sourceMapping.node
     };
     let styles = [];
-    const styleResources = extractStyleResources(this.resourceLoader, component, containingFile);
+    const externalStyles = [];
+    const styleResources = extractInlineStyleResources(component);
     const styleUrls = [
       ...extractComponentStyleUrls(this.evaluator, component),
       ..._extractTemplateStyleUrls(template)
@@ -13512,6 +13737,16 @@ var ComponentDecoratorHandler = class {
     for (const styleUrl of styleUrls) {
       try {
         const resourceUrl = this.resourceLoader.resolve(styleUrl.url, containingFile);
+        if (this.externalRuntimeStyles) {
+          externalStyles.push(resourceUrl);
+          continue;
+        }
+        if (styleUrl.source === 2 && ts47.isStringLiteralLike(styleUrl.expression)) {
+          styleResources.add({
+            path: absoluteFrom(resourceUrl),
+            expression: styleUrl.expression
+          });
+        }
         const resourceStr = this.resourceLoader.load(resourceUrl);
         styles.push(resourceStr);
         if (this.depTracker !== null) {
@@ -13525,7 +13760,7 @@ var ComponentDecoratorHandler = class {
           diagnostics = [];
         }
         const resourceType = styleUrl.source === 2 ? 2 : 1;
-        diagnostics.push(makeResourceNotFoundError(styleUrl.url, styleUrl.nodeForError, resourceType).toDiagnostic());
+        diagnostics.push(makeResourceNotFoundError(styleUrl.url, styleUrl.expression, resourceType).toDiagnostic());
       }
     }
     if (encapsulation === ViewEncapsulation2.ShadowDom && metadata.selector !== null) {
@@ -13541,8 +13776,12 @@ var ComponentDecoratorHandler = class {
     if (this.preanalyzeStylesCache.has(node)) {
       inlineStyles = this.preanalyzeStylesCache.get(node);
       this.preanalyzeStylesCache.delete(node);
-      if (inlineStyles !== null) {
-        styles.push(...inlineStyles);
+      if (inlineStyles == null ? void 0 : inlineStyles.length) {
+        if (this.externalRuntimeStyles) {
+          externalStyles.push(...inlineStyles);
+        } else {
+          styles.push(...inlineStyles);
+        }
       }
     } else {
       if (this.resourceLoader.canPreprocess) {
@@ -13555,9 +13794,9 @@ var ComponentDecoratorHandler = class {
           styles.push(...litStyles);
         }
       }
-    }
-    if (template.styles.length > 0) {
-      styles.push(...template.styles);
+      if (template.styles.length > 0) {
+        styles.push(...template.styles);
+      }
     }
     let explicitlyDeferredTypes = null;
     if (metadata.isStandalone && rawDeferredImports !== null) {
@@ -13587,17 +13826,19 @@ var ComponentDecoratorHandler = class {
           changeDetection,
           interpolation: (_d = template.interpolationConfig) != null ? _d : DEFAULT_INTERPOLATION_CONFIG2,
           styles,
+          externalStyles,
           animations,
           viewProviders: wrappedViewProviders,
           i18nUseExternalIds: this.i18nUseExternalIds,
           relativeContextFilePath,
-          rawImports: rawImports !== null ? new o2.WrappedNodeExpr(rawImports) : void 0
+          rawImports: rawImports !== null ? new o4.WrappedNodeExpr(rawImports) : void 0
         },
         typeCheckMeta: extractDirectiveTypeCheckMeta(node, inputs, this.reflector),
         classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorResources(dec, component, styles, template)) : null,
         classDebugInfo: extractClassDebugInfo(
           node,
           this.reflector,
+          this.compilerHost,
           this.rootDirs,
           this.forbidOrphanRendering
         ),
@@ -13651,6 +13892,7 @@ var ComponentDecoratorHandler = class {
       isStandalone: analysis.meta.isStandalone,
       isSignal: analysis.meta.isSignal,
       imports: analysis.resolvedImports,
+      rawImports: analysis.rawImports,
       deferredImports: analysis.resolvedDeferredImports,
       animationTriggerNames: analysis.animationTriggerNames,
       schemas: analysis.schemas,
@@ -13701,7 +13943,7 @@ var ComponentDecoratorHandler = class {
   }
   typeCheck(ctx, node, meta) {
     var _a;
-    if (this.typeCheckScopeRegistry === null || !ts45.isClassDeclaration(node)) {
+    if (this.typeCheckScopeRegistry === null || !ts47.isClassDeclaration(node)) {
       return;
     }
     if (meta.isPoisoned && !this.usePoisonedData) {
@@ -13938,11 +14180,11 @@ var ComponentDecoratorHandler = class {
         const importDiagnostics = validateStandaloneImports(analysis.resolvedDeferredImports, analysis.rawDeferredImports, this.metaReader, this.scopeReader, true);
         diagnostics.push(...importDiagnostics);
       }
-      if (analysis.providersRequiringFactory !== null && analysis.meta.providers instanceof o2.WrappedNodeExpr) {
+      if (analysis.providersRequiringFactory !== null && analysis.meta.providers instanceof o4.WrappedNodeExpr) {
         const providerDiagnostics = getProviderDiagnostics(analysis.providersRequiringFactory, analysis.meta.providers.node, this.injectableRegistry);
         diagnostics.push(...providerDiagnostics);
       }
-      if (analysis.viewProvidersRequiringFactory !== null && analysis.meta.viewProviders instanceof o2.WrappedNodeExpr) {
+      if (analysis.viewProvidersRequiringFactory !== null && analysis.meta.viewProviders instanceof o4.WrappedNodeExpr) {
         const viewProviderDiagnostics = getProviderDiagnostics(analysis.viewProvidersRequiringFactory, analysis.meta.viewProviders.node, this.injectableRegistry);
         diagnostics.push(...viewProviderDiagnostics);
       }
@@ -13995,20 +14237,24 @@ var ComponentDecoratorHandler = class {
     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(toFactoryMetadata(meta, FactoryTarget3.Component));
-    removeDeferrableTypesFromComponentDecorator(analysis, perComponentDeferredDeps);
+    if (perComponentDeferredDeps !== null) {
+      removeDeferrableTypesFromComponentDecorator(analysis, perComponentDeferredDeps);
+    }
     const def = compileComponentFromMetadata(meta, pool, makeBindingParser2());
     const inputTransformFields = compileInputTransformFields(analysis.inputs);
     const classMetadata = analysis.classMetadata !== null ? compileComponentClassMetadata(analysis.classMetadata, perComponentDeferredDeps).toStmt() : null;
     const debugInfo = analysis.classDebugInfo !== null ? compileClassDebugInfo(analysis.classDebugInfo).toStmt() : null;
-    const deferrableImports = this.deferredSymbolTracker.getDeferrableImportDecls();
-    return compileResults(fac, def, classMetadata, "\u0275cmp", 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 compileResults(fac, def, classMetadata, "\u0275cmp", inputTransformFields, deferrableImports, debugInfo, hmrInitializer);
   }
   compilePartial(node, analysis, resolution) {
     if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
@@ -14018,9 +14264,9 @@ var ComponentDecoratorHandler = class {
       content: analysis.template.content,
       sourceUrl: analysis.template.declaration.resolvedTemplateUrl,
       isInline: analysis.template.declaration.isInline,
-      inlineTemplateLiteralExpression: analysis.template.sourceMapping.type === "direct" ? new o2.WrappedNodeExpr(analysis.template.sourceMapping.node) : null
+      inlineTemplateLiteralExpression: analysis.template.sourceMapping.type === "direct" ? new o4.WrappedNodeExpr(analysis.template.sourceMapping.node) : null
     };
-    const perComponentDeferredDeps = this.resolveAllDeferredDependencies(resolution);
+    const perComponentDeferredDeps = this.canDeferDeps ? this.resolveAllDeferredDependencies(resolution) : null;
     const meta = {
       ...analysis.meta,
       ...resolution,
@@ -14030,26 +14276,48 @@ var ComponentDecoratorHandler = class {
     const inputTransformFields = compileInputTransformFields(analysis.inputs);
     const def = compileDeclareComponentFromMetadata(meta, analysis.template, templateInfo);
     const classMetadata = analysis.classMetadata !== null ? compileComponentDeclareClassMetadata(analysis.classMetadata, perComponentDeferredDeps).toStmt() : null;
-    const deferrableImports = this.deferredSymbolTracker.getDeferrableImportDecls();
-    return compileResults(fac, def, classMetadata, "\u0275cmp", 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 compileResults(fac, def, classMetadata, "\u0275cmp", inputTransformFields, deferrableImports, null, hmrInitializer);
   }
   compileLocal(node, analysis, resolution, pool) {
-    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(toFactoryMetadata(meta, FactoryTarget3.Component));
     const def = compileComponentFromMetadata(meta, pool, makeBindingParser2());
     const inputTransformFields = compileInputTransformFields(analysis.inputs);
     const classMetadata = analysis.classMetadata !== null ? compileComponentClassMetadata(analysis.classMetadata, deferrableTypes).toStmt() : null;
     const debugInfo = analysis.classDebugInfo !== null ? compileClassDebugInfo(analysis.classDebugInfo).toStmt() : null;
-    const deferrableImports = this.deferredSymbolTracker.getDeferrableImportDecls();
-    return compileResults(fac, def, classMetadata, "\u0275cmp", 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 compileResults(fac, def, classMetadata, "\u0275cmp", inputTransformFields, deferrableImports, debugInfo, hmrInitializer);
+  }
+  compileHmrUpdateDeclaration(node, analysis, resolution) {
+    if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
+      return null;
+    }
+    const pool = new ConstantPool2();
+    const meta = {
+      ...analysis.meta,
+      ...resolution,
+      defer: this.compileDeferBlocks(resolution)
+    };
+    const fac = compileNgFactoryDefField(toFactoryMetadata(meta, FactoryTarget3.Component));
+    const def = compileComponentFromMetadata(meta, pool, makeBindingParser2());
+    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 = compileResults(fac, def, classMetadata, "\u0275cmp", null, null, debugInfo, null);
+    return hmrMeta === null || res.length === 0 ? null : getHmrUpdateDeclaration(res, pool.statements, hmrMeta, node.getSourceFile());
   }
   locateDeferBlocksWithoutScope(template) {
     const deferBlocks = /* @__PURE__ */ new Map();
@@ -14079,12 +14347,12 @@ var ComponentDecoratorHandler = class {
   }
   collectExplicitlyDeferredSymbols(rawDeferredImports) {
     const deferredTypes = /* @__PURE__ */ new Map();
-    if (!ts45.isArrayLiteralExpression(rawDeferredImports)) {
+    if (!ts47.isArrayLiteralExpression(rawDeferredImports)) {
       return deferredTypes;
     }
     for (const element of rawDeferredImports.elements) {
       const node = tryUnwrapForwardRef(element, this.reflector) || element;
-      if (!ts45.isIdentifier(node)) {
+      if (!ts47.isIdentifier(node)) {
         continue;
       }
       const imp = this.reflector.getImportOfIdentifier(node);
@@ -14151,12 +14419,12 @@ var ComponentDecoratorHandler = class {
     }
   }
   registerDeferrableCandidates(componentClassDecl, importsExpr, isDeferredImport, allDeferredDecls, eagerlyUsedDecls, resolutionData) {
-    if (!ts45.isArrayLiteralExpression(importsExpr)) {
+    if (!ts47.isArrayLiteralExpression(importsExpr)) {
       return;
     }
     for (const element of importsExpr.elements) {
       const node = tryUnwrapForwardRef(element, this.reflector) || element;
-      if (!ts45.isIdentifier(node)) {
+      if (!ts47.isIdentifier(node)) {
         continue;
       }
       const imp = this.reflector.getImportOfIdentifier(node);
@@ -14240,7 +14508,7 @@ function removeDeferrableTypesFromComponentDecorator(analysis, deferrableTypes)
   if (analysis.classMetadata) {
     const deferrableSymbols = new Set(deferrableTypes.map((t) => t.symbolName));
     const rewrittenDecoratorsNode = removeIdentifierReferences(analysis.classMetadata.decorators.node, deferrableSymbols);
-    analysis.classMetadata.decorators = new o2.WrappedNodeExpr(rewrittenDecoratorsNode);
+    analysis.classMetadata.decorators = new o4.WrappedNodeExpr(rewrittenDecoratorsNode);
   }
 }
 function validateNoImportOverlap(eagerDeps, deferredDeps, rawDeferredImports) {
@@ -14290,7 +14558,7 @@ function isDefaultImport(node) {
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/injectable.mjs
 import { compileClassMetadata as compileClassMetadata3, compileDeclareClassMetadata as compileDeclareClassMetadata3, compileDeclareInjectableFromMetadata, compileInjectable, createMayBeForwardRefExpression as createMayBeForwardRefExpression3, FactoryTarget as FactoryTarget4, LiteralExpr as LiteralExpr3, WrappedNodeExpr as WrappedNodeExpr10 } from "@angular/compiler";
-import ts46 from "typescript";
+import ts48 from "typescript";
 var InjectableDecoratorHandler = class {
   constructor(reflector, evaluator, isCore, strictCtorDeps, injectableRegistry, perf, includeClassMetadata, compilationMode, errorOnDuplicateProv = true) {
     this.reflector = reflector;
@@ -14410,7 +14678,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     };
   } else if (decorator.args.length === 1) {
     const metaNode = decorator.args[0];
-    if (!ts46.isObjectLiteralExpression(metaNode)) {
+    if (!ts48.isObjectLiteralExpression(metaNode)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, metaNode, `@Injectable argument must be an object literal`);
     }
     const meta = reflectObjectLiteral(metaNode);
@@ -14418,7 +14686,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     let deps = void 0;
     if ((meta.has("useClass") || meta.has("useFactory")) && meta.has("deps")) {
       const depsExpr = meta.get("deps");
-      if (!ts46.isArrayLiteralExpression(depsExpr)) {
+      if (!ts48.isArrayLiteralExpression(depsExpr)) {
         throw new FatalDiagnosticError(ErrorCode.VALUE_NOT_LITERAL, depsExpr, `@Injectable deps metadata must be an inline array`);
       }
       deps = depsExpr.elements.map((dep) => getDep(dep, reflector));
@@ -14503,12 +14771,12 @@ function getDep(dep, reflector) {
     }
     return true;
   }
-  if (ts46.isArrayLiteralExpression(dep)) {
+  if (ts48.isArrayLiteralExpression(dep)) {
     dep.elements.forEach((el) => {
       let isDecorator = false;
-      if (ts46.isIdentifier(el)) {
+      if (ts48.isIdentifier(el)) {
         isDecorator = maybeUpdateDecorator(el, reflector);
-      } else if (ts46.isNewExpression(el) && ts46.isIdentifier(el.expression)) {
+      } else if (ts48.isNewExpression(el) && ts48.isIdentifier(el.expression)) {
         const token = el.arguments && el.arguments.length > 0 && el.arguments[0] || void 0;
         isDecorator = maybeUpdateDecorator(el.expression, reflector, token);
       }
@@ -14522,7 +14790,7 @@ function getDep(dep, reflector) {
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/pipe.mjs
 import { compileClassMetadata as compileClassMetadata4, compileDeclareClassMetadata as compileDeclareClassMetadata4, compileDeclarePipeFromMetadata, compilePipeFromMetadata, FactoryTarget as FactoryTarget5 } from "@angular/compiler";
-import ts47 from "typescript";
+import ts49 from "typescript";
 var PipeSymbol = class extends SemanticSymbol {
   constructor(decl, name) {
     super(decl);
@@ -14539,7 +14807,7 @@ var PipeSymbol = class extends SemanticSymbol {
   }
 };
 var PipeDecoratorHandler = class {
-  constructor(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, perf, includeClassMetadata, compilationMode, generateExtraImportsInLocalMode) {
+  constructor(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, perf, includeClassMetadata, compilationMode, generateExtraImportsInLocalMode, strictStandalone) {
     this.reflector = reflector;
     this.evaluator = evaluator;
     this.metaRegistry = metaRegistry;
@@ -14550,6 +14818,7 @@ var PipeDecoratorHandler = class {
     this.includeClassMetadata = includeClassMetadata;
     this.compilationMode = compilationMode;
     this.generateExtraImportsInLocalMode = generateExtraImportsInLocalMode;
+    this.strictStandalone = strictStandalone;
     this.precedence = HandlerPrecedence.PRIMARY;
     this.name = "PipeDecoratorHandler";
   }
@@ -14580,7 +14849,7 @@ var PipeDecoratorHandler = class {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, "@Pipe must have exactly one argument");
     }
     const meta = unwrapExpression(decorator.args[0]);
-    if (!ts47.isObjectLiteralExpression(meta)) {
+    if (!ts49.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@Pipe must have a literal argument");
     }
     const pipe = reflectObjectLiteral(meta);
@@ -14601,7 +14870,7 @@ var PipeDecoratorHandler = class {
       }
       pure = pureValue;
     }
-    let isStandalone = false;
+    let isStandalone = NG_STANDALONE_DEFAULT_VALUE;
     if (pipe.has("standalone")) {
       const expr = pipe.get("standalone");
       const resolved = this.evaluator.evaluate(expr);
@@ -14609,6 +14878,9 @@ var PipeDecoratorHandler = class {
         throw createValueHasWrongTypeError(expr, resolved, `standalone flag must be a boolean`);
       }
       isStandalone = resolved;
+      if (!isStandalone && this.strictStandalone) {
+        throw new FatalDiagnosticError(ErrorCode.NON_STANDALONE_NOT_ALLOWED, expr, `Only standalone pipes are allowed when 'strictStandalone' is enabled.`);
+      }
     }
     return {
       analysis: {
@@ -14741,7 +15013,14 @@ export {
  * 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.io/license
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * @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
  */
 /**
  * @license
@@ -14750,4 +15029,4 @@ export {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-//# sourceMappingURL=chunk-2SSA4Y5F.js.map
+//# sourceMappingURL=chunk-Q4DA5WRV.js.map