@angular/compiler-cli 15.0.0-next.5 → 15.0.0-rc.0

package/bundles/{chunk-VSAO3EZ7.js → chunk-KIQI22GZ.js}

@@ -13,7 +13,7 @@ import {
   reflectObjectLiteral,
   reflectTypeEntityToDeclaration,
   typeNodeToValueExpr
-} from "./chunk-XDX5RDY5.js";
+} from "./chunk-VZ2Q36OK.js";
 import {
   ErrorCode,
   FatalDiagnosticError,
@@ -33,7 +33,7 @@ import {
   translateExpression,
   translateStatement,
   translateType
-} from "./chunk-TF2TR2WS.js";
+} from "./chunk-JSLY52ZU.js";
 import {
   combineModifiers,
   createPropertyDeclaration,
@@ -46,18 +46,18 @@ import {
   updateParameterDeclaration,
   updatePropertyDeclaration,
   updateSetAccessorDeclaration
-} from "./chunk-7YHMCUJT.js";
+} from "./chunk-MEB4YHNS.js";
 import {
   absoluteFrom,
   absoluteFromSourceFile,
   relative
-} from "./chunk-TOKOIIBI.js";
+} from "./chunk-RC2GY3FU.js";
 import {
   PerfEvent,
   PerfPhase
-} from "./chunk-2HPI44CB.js";
+} from "./chunk-CTEVZGOM.js";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/util.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/util.mjs
 import { ExternalExpr, ParseLocation, ParseSourceFile, ParseSourceSpan, ReadPropExpr, WrappedNodeExpr } from "@angular/compiler";
 import ts from "typescript";
 function valueReferenceToExpression(valueRef) {
@@ -292,8 +292,11 @@ function getOriginNodeForDiagnostics(expr, container) {
     return container;
   }
 }
+function isAbstractClassDeclaration(clazz) {
+  return clazz.modifiers !== void 0 && clazz.modifiers.some((mod) => mod.kind === ts.SyntaxKind.AbstractKeyword);
+}
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/dynamic.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/dynamic.mjs
 var DynamicValue = class {
   constructor(node, reason, code) {
     this.node = node;
@@ -383,10 +386,10 @@ var DynamicValue = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.mjs
 import ts2 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/result.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/result.mjs
 var ResolvedModule = class {
   constructor(exports, evaluate) {
     this.exports = exports;
@@ -416,7 +419,7 @@ var EnumValue = class {
 var KnownFn = class {
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/builtin.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/builtin.mjs
 var ArraySliceBuiltinFn = class extends KnownFn {
   constructor(lhs) {
     super();
@@ -487,7 +490,7 @@ var ObjectAssignBuiltinFn = class extends KnownFn {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/ts_helpers.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/ts_helpers.mjs
 var AssignHelperFn = class extends ObjectAssignBuiltinFn {
 };
 var SpreadHelperFn = class extends KnownFn {
@@ -540,7 +543,7 @@ var ReadHelperFn = class extends KnownFn {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/known_declaration.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/known_declaration.mjs
 var jsGlobalObjectValue = /* @__PURE__ */ new Map([["assign", new ObjectAssignBuiltinFn()]]);
 var assignTsHelperFn = new AssignHelperFn();
 var spreadTsHelperFn = new SpreadHelperFn();
@@ -564,14 +567,14 @@ function resolveKnownDeclaration(decl) {
   }
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/synthetic.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/synthetic.mjs
 var SyntheticValue = class {
   constructor(value) {
     this.value = value;
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.mjs
 function literalBinaryOp(op) {
   return { op, literal: true };
 }
@@ -1157,7 +1160,7 @@ function owningModule(context, override = null) {
   }
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interface.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interface.mjs
 var PartialEvaluator = class {
   constructor(host, checker, dependencyTracker) {
     this.host = host;
@@ -1177,7 +1180,7 @@ var PartialEvaluator = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/diagnostics.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/diagnostics.mjs
 import ts3 from "typescript";
 function describeResolvedType(value, maxDepth = 1) {
   var _a, _b;
@@ -1307,7 +1310,7 @@ function getContainerNode(node) {
   return node.getSourceFile();
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/di.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/di.mjs
 import { LiteralExpr, WrappedNodeExpr as WrappedNodeExpr2 } from "@angular/compiler";
 import ts4 from "typescript";
 function getConstructorDependencies(clazz, reflector, isCore) {
@@ -1451,1191 +1454,1255 @@ function createUnsuitableInjectionTokenError(clazz, error) {
   return new FatalDiagnosticError(ErrorCode.PARAM_MISSING_TOKEN, param.nameNode, chain, hints);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/diagnostics.mjs
-import ts5 from "typescript";
-function makeDuplicateDeclarationError(node, data, kind) {
-  const context = [];
-  for (const decl of data) {
-    if (decl.rawDeclarations === null) {
-      continue;
-    }
-    const contextNode = decl.ref.getOriginForDiagnostics(decl.rawDeclarations, decl.ngModule.name);
-    context.push(makeRelatedInformation(contextNode, `'${node.name.text}' is listed in the declarations of the NgModule '${decl.ngModule.name.text}'.`));
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/diagnostics.mjs
+import ts7 from "typescript";
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/api.mjs
+var MetaKind;
+(function(MetaKind2) {
+  MetaKind2[MetaKind2["Directive"] = 0] = "Directive";
+  MetaKind2[MetaKind2["Pipe"] = 1] = "Pipe";
+  MetaKind2[MetaKind2["NgModule"] = 2] = "NgModule";
+})(MetaKind || (MetaKind = {}));
+var MatchSource;
+(function(MatchSource2) {
+  MatchSource2[MatchSource2["Selector"] = 0] = "Selector";
+  MatchSource2[MatchSource2["HostDirective"] = 1] = "HostDirective";
+})(MatchSource || (MatchSource = {}));
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/dts.mjs
+import ts6 from "typescript";
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/property_mapping.mjs
+var ClassPropertyMapping = class {
+  constructor(forwardMap) {
+    this.forwardMap = forwardMap;
+    this.reverseMap = reverseMapFromForwardMap(forwardMap);
   }
-  return makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_NOT_UNIQUE, node.name, `The ${kind} '${node.name.text}' is declared by more than one NgModule.`, context);
-}
-function createValueHasWrongTypeError(node, value, messageText) {
-  var _a;
-  let chainedMessage;
-  let relatedInformation;
-  if (value instanceof DynamicValue) {
-    chainedMessage = "Value could not be determined statically.";
-    relatedInformation = traceDynamicValue(node, value);
-  } else if (value instanceof Reference) {
-    const target = value.debugName !== null ? `'${value.debugName}'` : "an anonymous declaration";
-    chainedMessage = `Value is a reference to ${target}.`;
-    const referenceNode = (_a = identifierOfNode(value.node)) != null ? _a : value.node;
-    relatedInformation = [makeRelatedInformation(referenceNode, "Reference is declared here.")];
-  } else {
-    chainedMessage = `Value is of type '${describeResolvedType(value)}'.`;
+  static empty() {
+    return new ClassPropertyMapping(/* @__PURE__ */ new Map());
   }
-  const chain = {
-    messageText,
-    category: ts5.DiagnosticCategory.Error,
-    code: 0,
-    next: [{
-      messageText: chainedMessage,
-      category: ts5.DiagnosticCategory.Message,
-      code: 0
-    }]
-  };
-  return new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, node, chain, relatedInformation);
-}
-function getProviderDiagnostics(providerClasses, providersDeclaration, registry) {
-  const diagnostics = [];
-  for (const provider of providerClasses) {
-    if (registry.isInjectable(provider.node)) {
-      continue;
+  static fromMappedObject(obj) {
+    const forwardMap = /* @__PURE__ */ new Map();
+    for (const classPropertyName of Object.keys(obj)) {
+      const value = obj[classPropertyName];
+      const bindingPropertyName = Array.isArray(value) ? value[0] : value;
+      const inputOrOutput = { classPropertyName, bindingPropertyName };
+      forwardMap.set(classPropertyName, inputOrOutput);
     }
-    const contextNode = provider.getOriginForDiagnostics(providersDeclaration);
-    diagnostics.push(makeDiagnostic(ErrorCode.UNDECORATED_PROVIDER, contextNode, `The class '${provider.node.name.text}' cannot be created via dependency injection, as it does not have an Angular decorator. This will result in an error at runtime.
-
-Either add the @Injectable() decorator to '${provider.node.name.text}', or configure a different provider (such as a provider with 'useFactory').
-`, [makeRelatedInformation(provider.node, `'${provider.node.name.text}' is declared here.`)]));
+    return new ClassPropertyMapping(forwardMap);
   }
-  return diagnostics;
-}
-function getDirectiveDiagnostics(node, reader, evaluator, reflector, scopeRegistry, kind) {
-  let diagnostics = [];
-  const addDiagnostics = (more) => {
-    if (more === null) {
-      return;
-    } else if (diagnostics === null) {
-      diagnostics = Array.isArray(more) ? more : [more];
-    } else if (Array.isArray(more)) {
-      diagnostics.push(...more);
-    } else {
-      diagnostics.push(more);
+  static merge(a, b) {
+    const forwardMap = new Map(a.forwardMap.entries());
+    for (const [classPropertyName, inputOrOutput] of b.forwardMap) {
+      forwardMap.set(classPropertyName, inputOrOutput);
     }
-  };
-  const duplicateDeclarations = scopeRegistry.getDuplicateDeclarations(node);
-  if (duplicateDeclarations !== null) {
-    addDiagnostics(makeDuplicateDeclarationError(node, duplicateDeclarations, kind));
+    return new ClassPropertyMapping(forwardMap);
   }
-  addDiagnostics(checkInheritanceOfDirective(node, reader, reflector, evaluator));
-  return diagnostics;
-}
-function validateHostDirectives(origin, hostDirectives, metaReader) {
-  const diagnostics = [];
-  for (const current of hostDirectives) {
-    const hostMeta = metaReader.getDirectiveMetadata(current.directive);
-    if (hostMeta === null) {
-      diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_INVALID, current.directive.getOriginForDiagnostics(origin), `${current.directive.debugName} must be a standalone directive to be used as a host directive`));
-      continue;
-    }
-    if (!hostMeta.isStandalone) {
-      diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_NOT_STANDALONE, current.directive.getOriginForDiagnostics(origin), `Host directive ${hostMeta.name} must be standalone`));
-    }
-    if (hostMeta.isComponent) {
-      diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_COMPONENT, current.directive.getOriginForDiagnostics(origin), `Host directive ${hostMeta.name} cannot be a component`));
-    }
+  get classPropertyNames() {
+    return Array.from(this.forwardMap.keys());
   }
-  return diagnostics;
-}
-function getUndecoratedClassWithAngularFeaturesDiagnostic(node) {
-  return makeDiagnostic(ErrorCode.UNDECORATED_CLASS_USING_ANGULAR_FEATURES, node.name, `Class is using Angular features but is not decorated. Please add an explicit Angular decorator.`);
-}
-function checkInheritanceOfDirective(node, reader, reflector, evaluator) {
-  if (!reflector.isClass(node) || reflector.getConstructorParameters(node) !== null) {
-    return null;
+  get propertyNames() {
+    return Array.from(this.reverseMap.keys());
   }
-  let baseClass = readBaseClass(node, reflector, evaluator);
-  while (baseClass !== null) {
-    if (baseClass === "dynamic") {
-      return null;
+  hasBindingPropertyName(propertyName) {
+    return this.reverseMap.has(propertyName);
+  }
+  getByBindingPropertyName(propertyName) {
+    return this.reverseMap.has(propertyName) ? this.reverseMap.get(propertyName) : null;
+  }
+  getByClassPropertyName(classPropertyName) {
+    return this.forwardMap.has(classPropertyName) ? this.forwardMap.get(classPropertyName) : null;
+  }
+  toDirectMappedObject() {
+    const obj = {};
+    for (const [classPropertyName, inputOrOutput] of this.forwardMap) {
+      obj[classPropertyName] = inputOrOutput.bindingPropertyName;
     }
-    const baseClassMeta = reader.getDirectiveMetadata(baseClass);
-    if (baseClassMeta !== null) {
-      return null;
+    return obj;
+  }
+  toJointMappedObject() {
+    const obj = {};
+    for (const [classPropertyName, inputOrOutput] of this.forwardMap) {
+      if (inputOrOutput.bindingPropertyName === classPropertyName) {
+        obj[classPropertyName] = inputOrOutput.bindingPropertyName;
+      } else {
+        obj[classPropertyName] = [inputOrOutput.bindingPropertyName, classPropertyName];
+      }
     }
-    const baseClassConstructorParams = reflector.getConstructorParameters(baseClass.node);
-    const newParentClass = readBaseClass(baseClass.node, reflector, evaluator);
-    if (baseClassConstructorParams !== null && baseClassConstructorParams.length > 0) {
-      return getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader);
-    } else if (baseClassConstructorParams !== null || newParentClass === null) {
-      return null;
+    return obj;
+  }
+  *[Symbol.iterator]() {
+    for (const [classPropertyName, inputOrOutput] of this.forwardMap.entries()) {
+      yield [classPropertyName, inputOrOutput.bindingPropertyName];
     }
-    baseClass = newParentClass;
   }
-  return null;
-}
-function getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader) {
-  const subclassMeta = reader.getDirectiveMetadata(new Reference(node));
-  const dirOrComp = subclassMeta.isComponent ? "Component" : "Directive";
-  const baseClassName = baseClass.debugName;
-  return makeDiagnostic(ErrorCode.DIRECTIVE_INHERITS_UNDECORATED_CTOR, node.name, `The ${dirOrComp.toLowerCase()} ${node.name.text} inherits its constructor from ${baseClassName}, but the latter does not have an Angular decorator of its own. Dependency injection will not be able to resolve the parameters of ${baseClassName}'s constructor. Either add a @Directive decorator to ${baseClassName}, or add an explicit constructor to ${node.name.text}.`);
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/evaluation.mjs
-import ts6 from "typescript";
-function resolveEnumValue(evaluator, metadata, field, enumSymbolName) {
-  let resolved = null;
-  if (metadata.has(field)) {
-    const expr = metadata.get(field);
-    const value = evaluator.evaluate(expr);
-    if (value instanceof EnumValue && isAngularCoreReference(value.enumRef, enumSymbolName)) {
-      resolved = value.resolved;
-    } else {
-      throw createValueHasWrongTypeError(expr, value, `${field} must be a member of ${enumSymbolName} enum from @angular/core`);
+};
+function reverseMapFromForwardMap(forwardMap) {
+  const reverseMap = /* @__PURE__ */ new Map();
+  for (const [_, inputOrOutput] of forwardMap) {
+    if (!reverseMap.has(inputOrOutput.bindingPropertyName)) {
+      reverseMap.set(inputOrOutput.bindingPropertyName, []);
     }
+    reverseMap.get(inputOrOutput.bindingPropertyName).push(inputOrOutput);
   }
-  return resolved;
-}
-function isStringArray(resolvedValue) {
-  return Array.isArray(resolvedValue) && resolvedValue.every((elem) => typeof elem === "string");
+  return reverseMap;
 }
-function resolveLiteral(decorator, literalCache) {
-  if (literalCache.has(decorator)) {
-    return literalCache.get(decorator);
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/util.mjs
+import ts5 from "typescript";
+function extractReferencesFromType(checker, def, bestGuessOwningModule) {
+  if (!ts5.isTupleTypeNode(def)) {
+    return [];
   }
-  if (decorator.args === null || decorator.args.length !== 1) {
-    throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @${decorator.name} decorator`);
+  return def.elements.map((element) => {
+    if (!ts5.isTypeQueryNode(element)) {
+      throw new Error(`Expected TypeQueryNode: ${nodeDebugInfo(element)}`);
+    }
+    return extraReferenceFromTypeQuery(checker, element, def, bestGuessOwningModule);
+  });
+}
+function extraReferenceFromTypeQuery(checker, typeNode, origin, bestGuessOwningModule) {
+  const type = typeNode.exprName;
+  const { node, from } = reflectTypeEntityToDeclaration(type, checker);
+  if (!isNamedClassDeclaration(node)) {
+    throw new Error(`Expected named ClassDeclaration: ${nodeDebugInfo(node)}`);
   }
-  const meta = unwrapExpression(decorator.args[0]);
-  if (!ts6.isObjectLiteralExpression(meta)) {
-    throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `Decorator argument must be literal.`);
+  if (from !== null && !from.startsWith(".")) {
+    return new Reference(node, { specifier: from, resolutionContext: origin.getSourceFile().fileName });
   }
-  literalCache.set(decorator, meta);
-  return meta;
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/factory.mjs
-import { compileDeclareFactoryFunction, compileFactoryFunction } from "@angular/compiler";
-function compileNgFactoryDefField(metadata) {
-  const res = compileFactoryFunction(metadata);
-  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
-}
-function compileDeclareFactory(metadata) {
-  const res = compileDeclareFactoryFunction(metadata);
-  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
+  return new Reference(node, bestGuessOwningModule);
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/metadata.mjs
-import { FunctionExpr, LiteralArrayExpr, LiteralExpr as LiteralExpr2, literalMap, ReturnStatement, WrappedNodeExpr as WrappedNodeExpr3 } from "@angular/compiler";
-import ts7 from "typescript";
-function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompiler, angularDecoratorTransform = (dec) => dec) {
-  if (!reflection.isClass(clazz)) {
+function readBooleanType(type) {
+  if (!ts5.isLiteralTypeNode(type)) {
     return null;
   }
-  const id = reflection.getAdjacentNameOfClass(clazz);
-  const classDecorators = reflection.getDecoratorsOfDeclaration(clazz);
-  if (classDecorators === null) {
-    return null;
+  switch (type.literal.kind) {
+    case ts5.SyntaxKind.TrueKeyword:
+      return true;
+    case ts5.SyntaxKind.FalseKeyword:
+      return false;
+    default:
+      return null;
   }
-  const ngClassDecorators = classDecorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(angularDecoratorTransform(decorator), annotateForClosureCompiler)).map((decorator) => removeIdentifierReferences(decorator, id.text));
-  if (ngClassDecorators.length === 0) {
+}
+function readStringType(type) {
+  if (!ts5.isLiteralTypeNode(type) || !ts5.isStringLiteral(type.literal)) {
     return null;
   }
-  const metaDecorators = new WrappedNodeExpr3(ts7.factory.createArrayLiteralExpression(ngClassDecorators));
-  let metaCtorParameters = null;
-  const classCtorParameters = reflection.getConstructorParameters(clazz);
-  if (classCtorParameters !== null) {
-    const ctorParameters = classCtorParameters.map((param) => ctorParameterToMetadata(param, isCore));
-    metaCtorParameters = new FunctionExpr([], [
-      new ReturnStatement(new LiteralArrayExpr(ctorParameters))
-    ]);
-  }
-  let metaPropDecorators = null;
-  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && member.decorators !== null && member.decorators.length > 0);
-  const duplicateDecoratedMemberNames = classMembers.map((member) => member.name).filter((name, i, arr) => arr.indexOf(name) < i);
-  if (duplicateDecoratedMemberNames.length > 0) {
-    throw new Error(`Duplicate decorated properties found on class '${clazz.name.text}': ` + duplicateDecoratedMemberNames.join(", "));
+  return type.literal.text;
+}
+function readMapType(type, valueTransform) {
+  if (!ts5.isTypeLiteralNode(type)) {
+    return {};
   }
-  const decoratedMembers = classMembers.map((member) => {
-    var _a;
-    return classMemberToMetadata((_a = member.nameNode) != null ? _a : member.name, member.decorators, isCore);
+  const obj = {};
+  type.members.forEach((member) => {
+    if (!ts5.isPropertySignature(member) || member.type === void 0 || member.name === void 0 || !ts5.isStringLiteral(member.name) && !ts5.isIdentifier(member.name)) {
+      return;
+    }
+    const value = valueTransform(member.type);
+    if (value === null) {
+      return null;
+    }
+    obj[member.name.text] = value;
   });
-  if (decoratedMembers.length > 0) {
-    metaPropDecorators = new WrappedNodeExpr3(ts7.factory.createObjectLiteralExpression(decoratedMembers));
-  }
-  return {
-    type: new WrappedNodeExpr3(id),
-    decorators: metaDecorators,
-    ctorParameters: metaCtorParameters,
-    propDecorators: metaPropDecorators
-  };
+  return obj;
 }
-function ctorParameterToMetadata(param, isCore) {
-  const type = param.typeValueReference.kind !== 2 ? valueReferenceToExpression(param.typeValueReference) : new LiteralExpr2(void 0);
-  const mapEntries = [
-    { key: "type", value: type, quoted: false }
-  ];
-  if (param.decorators !== null) {
-    const ngDecorators = param.decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(decorator));
-    const value = new WrappedNodeExpr3(ts7.factory.createArrayLiteralExpression(ngDecorators));
-    mapEntries.push({ key: "decorators", value, quoted: false });
+function readStringArrayType(type) {
+  if (!ts5.isTupleTypeNode(type)) {
+    return [];
   }
-  return literalMap(mapEntries);
-}
-function classMemberToMetadata(name, decorators, isCore) {
-  const ngDecorators = decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(decorator));
-  const decoratorMeta = ts7.factory.createArrayLiteralExpression(ngDecorators);
-  return ts7.factory.createPropertyAssignment(name, decoratorMeta);
+  const res = [];
+  type.elements.forEach((el) => {
+    if (!ts5.isLiteralTypeNode(el) || !ts5.isStringLiteral(el.literal)) {
+      return;
+    }
+    res.push(el.literal.text);
+  });
+  return res;
 }
-function decoratorToMetadata(decorator, wrapFunctionsInParens) {
-  if (decorator.identifier === null) {
-    throw new Error("Illegal state: synthesized decorator cannot be emitted in class metadata.");
-  }
-  const properties = [
-    ts7.factory.createPropertyAssignment("type", decorator.identifier)
-  ];
-  if (decorator.args !== null && decorator.args.length > 0) {
-    const args = decorator.args.map((arg) => {
-      return wrapFunctionsInParens ? wrapFunctionExpressionsInParens(arg) : arg;
-    });
-    properties.push(ts7.factory.createPropertyAssignment("args", ts7.factory.createArrayLiteralExpression(args)));
+function extractDirectiveTypeCheckMeta(node, inputs, reflector) {
+  const members = reflector.getMembersOfClass(node);
+  const staticMembers = members.filter((member) => member.isStatic);
+  const ngTemplateGuards = staticMembers.map(extractTemplateGuard).filter((guard) => guard !== null);
+  const hasNgTemplateContextGuard = staticMembers.some((member) => member.kind === ClassMemberKind.Method && member.name === "ngTemplateContextGuard");
+  const coercedInputFields = new Set(staticMembers.map(extractCoercedInput).filter((inputName) => inputName !== null));
+  const restrictedInputFields = /* @__PURE__ */ new Set();
+  const stringLiteralInputFields = /* @__PURE__ */ new Set();
+  const undeclaredInputFields = /* @__PURE__ */ new Set();
+  for (const classPropertyName of inputs.classPropertyNames) {
+    const field = members.find((member) => member.name === classPropertyName);
+    if (field === void 0 || field.node === null) {
+      undeclaredInputFields.add(classPropertyName);
+      continue;
+    }
+    if (isRestricted(field.node)) {
+      restrictedInputFields.add(classPropertyName);
+    }
+    if (field.nameNode !== null && ts5.isStringLiteral(field.nameNode)) {
+      stringLiteralInputFields.add(classPropertyName);
+    }
   }
-  return ts7.factory.createObjectLiteralExpression(properties, true);
-}
-function isAngularDecorator2(decorator, isCore) {
-  return isCore || decorator.import !== null && decorator.import.from === "@angular/core";
+  const arity = reflector.getGenericArityOfClass(node);
+  return {
+    hasNgTemplateContextGuard,
+    ngTemplateGuards,
+    coercedInputFields,
+    restrictedInputFields,
+    stringLiteralInputFields,
+    undeclaredInputFields,
+    isGeneric: arity !== null && arity > 0
+  };
 }
-function removeIdentifierReferences(node, name) {
-  const result = ts7.transform(node, [(context) => (root) => ts7.visitNode(root, function walk(current) {
-    return ts7.isIdentifier(current) && current.text === name ? ts7.factory.createIdentifier(current.text) : ts7.visitEachChild(current, walk, context);
-  })]);
-  return result.transformed[0];
+function isRestricted(node) {
+  const modifiers = getModifiers(node);
+  return modifiers !== void 0 && modifiers.some(({ kind }) => {
+    return kind === ts5.SyntaxKind.PrivateKeyword || kind === ts5.SyntaxKind.ProtectedKeyword || kind === ts5.SyntaxKind.ReadonlyKeyword;
+  });
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/references_registry.mjs
-var NoopReferencesRegistry = class {
-  add(source, ...references) {
-  }
-};
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/schema.mjs
-import { CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA } from "@angular/compiler";
-function extractSchemas(rawExpr, evaluator, context) {
-  const schemas = [];
-  const result = evaluator.evaluate(rawExpr);
-  if (!Array.isArray(result)) {
-    throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array`);
+function extractTemplateGuard(member) {
+  if (!member.name.startsWith("ngTemplateGuard_")) {
+    return null;
   }
-  for (const schemaRef of result) {
-    if (!(schemaRef instanceof Reference)) {
-      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
-    }
-    const id = schemaRef.getIdentityIn(schemaRef.node.getSourceFile());
-    if (id === null || schemaRef.ownedByModuleGuess !== "@angular/core") {
-      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
+  const inputName = afterUnderscore(member.name);
+  if (member.kind === ClassMemberKind.Property) {
+    let type = null;
+    if (member.type !== null && ts5.isLiteralTypeNode(member.type) && ts5.isStringLiteral(member.type.literal)) {
+      type = member.type.literal.text;
     }
-    switch (id.text) {
-      case "CUSTOM_ELEMENTS_SCHEMA":
-        schemas.push(CUSTOM_ELEMENTS_SCHEMA);
-        break;
-      case "NO_ERRORS_SCHEMA":
-        schemas.push(NO_ERRORS_SCHEMA);
-        break;
-      default:
-        throw createValueHasWrongTypeError(rawExpr, schemaRef, `'${schemaRef.debugName}' is not a valid ${context} schema`);
+    if (type !== "binding") {
+      return null;
     }
+    return { inputName, type };
+  } else if (member.kind === ClassMemberKind.Method) {
+    return { inputName, type: "invocation" };
+  } else {
+    return null;
   }
-  return schemas;
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
-import { compileClassMetadata as compileClassMetadata3, compileComponentFromMetadata, compileDeclareClassMetadata as compileDeclareClassMetadata3, compileDeclareComponentFromMetadata, CssSelector as CssSelector2, DEFAULT_INTERPOLATION_CONFIG as DEFAULT_INTERPOLATION_CONFIG2, DomElementSchemaRegistry, FactoryTarget as FactoryTarget3, makeBindingParser as makeBindingParser2, R3TargetBinder, R3TemplateDependencyKind, SelectorMatcher as SelectorMatcher2, ViewEncapsulation, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
-import ts24 from "typescript";
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.mjs
-import ts8 from "typescript";
-var SemanticSymbol = class {
-  constructor(decl) {
-    this.decl = decl;
-    this.path = absoluteFromSourceFile(decl.getSourceFile());
-    this.identifier = getSymbolIdentifier(decl);
-  }
-};
-function getSymbolIdentifier(decl) {
-  if (!ts8.isSourceFile(decl.parent)) {
+function extractCoercedInput(member) {
+  if (member.kind !== ClassMemberKind.Property || !member.name.startsWith("ngAcceptInputType_")) {
     return null;
   }
-  return decl.name.text;
+  return afterUnderscore(member.name);
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/graph.mjs
-import { ExternalExpr as ExternalExpr2 } from "@angular/compiler";
-var OpaqueSymbol = class extends SemanticSymbol {
-  isPublicApiAffected() {
-    return false;
-  }
-  isTypeCheckApiAffected() {
-    return false;
-  }
-};
-var SemanticDepGraph = class {
-  constructor() {
-    this.files = /* @__PURE__ */ new Map();
-    this.symbolByDecl = /* @__PURE__ */ new Map();
+var CompoundMetadataReader = class {
+  constructor(readers) {
+    this.readers = readers;
   }
-  registerSymbol(symbol) {
-    this.symbolByDecl.set(symbol.decl, symbol);
-    if (symbol.identifier !== null) {
-      if (!this.files.has(symbol.path)) {
-        this.files.set(symbol.path, /* @__PURE__ */ new Map());
+  getDirectiveMetadata(node) {
+    for (const reader of this.readers) {
+      const meta = reader.getDirectiveMetadata(node);
+      if (meta !== null) {
+        return meta;
       }
-      this.files.get(symbol.path).set(symbol.identifier, symbol);
-    }
-  }
-  getEquivalentSymbol(symbol) {
-    let previousSymbol = this.getSymbolByDecl(symbol.decl);
-    if (previousSymbol === null && symbol.identifier !== null) {
-      previousSymbol = this.getSymbolByName(symbol.path, symbol.identifier);
     }
-    return previousSymbol;
+    return null;
   }
-  getSymbolByName(path, identifier) {
-    if (!this.files.has(path)) {
-      return null;
-    }
-    const file = this.files.get(path);
-    if (!file.has(identifier)) {
-      return null;
+  getNgModuleMetadata(node) {
+    for (const reader of this.readers) {
+      const meta = reader.getNgModuleMetadata(node);
+      if (meta !== null) {
+        return meta;
+      }
     }
-    return file.get(identifier);
+    return null;
   }
-  getSymbolByDecl(decl) {
-    if (!this.symbolByDecl.has(decl)) {
-      return null;
+  getPipeMetadata(node) {
+    for (const reader of this.readers) {
+      const meta = reader.getPipeMetadata(node);
+      if (meta !== null) {
+        return meta;
+      }
     }
-    return this.symbolByDecl.get(decl);
+    return null;
   }
 };
-var SemanticDepGraphUpdater = class {
-  constructor(priorGraph) {
-    this.priorGraph = priorGraph;
-    this.newGraph = new SemanticDepGraph();
-    this.opaqueSymbols = /* @__PURE__ */ new Map();
+function afterUnderscore(str) {
+  const pos = str.indexOf("_");
+  if (pos === -1) {
+    throw new Error(`Expected '${str}' to contain '_'`);
   }
-  registerSymbol(symbol) {
-    this.newGraph.registerSymbol(symbol);
+  return str.slice(pos + 1);
+}
+function hasInjectableFields(clazz, host) {
+  const members = host.getMembersOfClass(clazz);
+  return members.some(({ isStatic, name }) => isStatic && (name === "\u0275prov" || name === "\u0275fac"));
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/dts.mjs
+var DtsMetadataReader = class {
+  constructor(checker, reflector) {
+    this.checker = checker;
+    this.reflector = reflector;
   }
-  finalize() {
-    if (this.priorGraph === null) {
-      return {
-        needsEmit: /* @__PURE__ */ new Set(),
-        needsTypeCheckEmit: /* @__PURE__ */ new Set(),
-        newGraph: this.newGraph
-      };
+  getNgModuleMetadata(ref) {
+    const clazz = ref.node;
+    const ngModuleDef = this.reflector.getMembersOfClass(clazz).find((member) => member.name === "\u0275mod" && member.isStatic);
+    if (ngModuleDef === void 0) {
+      return null;
+    } else if (ngModuleDef.type === null || !ts6.isTypeReferenceNode(ngModuleDef.type) || ngModuleDef.type.typeArguments === void 0 || ngModuleDef.type.typeArguments.length !== 4) {
+      return null;
     }
-    const needsEmit = this.determineInvalidatedFiles(this.priorGraph);
-    const needsTypeCheckEmit = this.determineInvalidatedTypeCheckFiles(this.priorGraph);
+    const [_, declarationMetadata, importMetadata, exportMetadata] = ngModuleDef.type.typeArguments;
     return {
-      needsEmit,
-      needsTypeCheckEmit,
-      newGraph: this.newGraph
-    };
-  }
-  determineInvalidatedFiles(priorGraph) {
-    const isPublicApiAffected = /* @__PURE__ */ new Set();
-    for (const symbol of this.newGraph.symbolByDecl.values()) {
-      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
-      if (previousSymbol === null || symbol.isPublicApiAffected(previousSymbol)) {
-        isPublicApiAffected.add(symbol);
-      }
-    }
-    const needsEmit = /* @__PURE__ */ new Set();
-    for (const symbol of this.newGraph.symbolByDecl.values()) {
-      if (symbol.isEmitAffected === void 0) {
-        continue;
-      }
-      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
-      if (previousSymbol === null || symbol.isEmitAffected(previousSymbol, isPublicApiAffected)) {
-        needsEmit.add(symbol.path);
-      }
-    }
-    return needsEmit;
+      kind: MetaKind.NgModule,
+      ref,
+      declarations: extractReferencesFromType(this.checker, declarationMetadata, ref.bestGuessOwningModule),
+      exports: extractReferencesFromType(this.checker, exportMetadata, ref.bestGuessOwningModule),
+      imports: extractReferencesFromType(this.checker, importMetadata, ref.bestGuessOwningModule),
+      schemas: [],
+      rawDeclarations: null,
+      rawImports: null,
+      rawExports: null,
+      decorator: null
+    };
   }
-  determineInvalidatedTypeCheckFiles(priorGraph) {
-    const isTypeCheckApiAffected = /* @__PURE__ */ new Set();
-    for (const symbol of this.newGraph.symbolByDecl.values()) {
-      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
-      if (previousSymbol === null || symbol.isTypeCheckApiAffected(previousSymbol)) {
-        isTypeCheckApiAffected.add(symbol);
-      }
-    }
-    const needsTypeCheckEmit = /* @__PURE__ */ new Set();
-    for (const symbol of this.newGraph.symbolByDecl.values()) {
-      if (symbol.isTypeCheckBlockAffected === void 0) {
-        continue;
-      }
-      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
-      if (previousSymbol === null || symbol.isTypeCheckBlockAffected(previousSymbol, isTypeCheckApiAffected)) {
-        needsTypeCheckEmit.add(symbol.path);
-      }
+  getDirectiveMetadata(ref) {
+    var _a;
+    const clazz = ref.node;
+    const def = this.reflector.getMembersOfClass(clazz).find((field) => field.isStatic && (field.name === "\u0275cmp" || field.name === "\u0275dir"));
+    if (def === void 0) {
+      return null;
+    } else if (def.type === null || !ts6.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
+      return null;
     }
-    return needsTypeCheckEmit;
-  }
-  getSemanticReference(decl, expr) {
+    const isComponent = def.name === "\u0275cmp";
+    const ctorParams = this.reflector.getConstructorParameters(clazz);
+    const isStructural = !isComponent && ctorParams !== null && ctorParams.some((param) => {
+      return param.typeValueReference.kind === 1 && param.typeValueReference.moduleName === "@angular/core" && param.typeValueReference.importedName === "TemplateRef";
+    });
+    const isStandalone = def.type.typeArguments.length > 7 && ((_a = readBooleanType(def.type.typeArguments[7])) != null ? _a : false);
+    const inputs = ClassPropertyMapping.fromMappedObject(readMapType(def.type.typeArguments[3], readStringType));
+    const outputs = ClassPropertyMapping.fromMappedObject(readMapType(def.type.typeArguments[4], readStringType));
+    const hostDirectives = def.type.typeArguments.length > 8 ? readHostDirectivesType(this.checker, def.type.typeArguments[8], ref.bestGuessOwningModule) : null;
     return {
-      symbol: this.getSymbol(decl),
-      importPath: getImportPath(expr)
+      kind: MetaKind.Directive,
+      matchSource: MatchSource.Selector,
+      ref,
+      name: clazz.name.text,
+      isComponent,
+      selector: readStringType(def.type.typeArguments[1]),
+      exportAs: readStringArrayType(def.type.typeArguments[2]),
+      inputs,
+      outputs,
+      hostDirectives,
+      queries: readStringArrayType(def.type.typeArguments[5]),
+      ...extractDirectiveTypeCheckMeta(clazz, inputs, this.reflector),
+      baseClass: readBaseClass2(clazz, this.checker, this.reflector),
+      isPoisoned: false,
+      isStructural,
+      animationTriggerNames: null,
+      isStandalone,
+      imports: null,
+      schemas: null,
+      decorator: null
     };
   }
-  getSymbol(decl) {
-    const symbol = this.newGraph.getSymbolByDecl(decl);
-    if (symbol === null) {
-      return this.getOpaqueSymbol(decl);
+  getPipeMetadata(ref) {
+    var _a;
+    const def = this.reflector.getMembersOfClass(ref.node).find((field) => field.isStatic && field.name === "\u0275pipe");
+    if (def === void 0) {
+      return null;
+    } else if (def.type === null || !ts6.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
+      return null;
     }
-    return symbol;
-  }
-  getOpaqueSymbol(decl) {
-    if (this.opaqueSymbols.has(decl)) {
-      return this.opaqueSymbols.get(decl);
+    const type = def.type.typeArguments[1];
+    if (!ts6.isLiteralTypeNode(type) || !ts6.isStringLiteral(type.literal)) {
+      return null;
     }
-    const symbol = new OpaqueSymbol(decl);
-    this.opaqueSymbols.set(decl, symbol);
-    return symbol;
+    const name = type.literal.text;
+    const isStandalone = def.type.typeArguments.length > 2 && ((_a = readBooleanType(def.type.typeArguments[2])) != null ? _a : false);
+    return {
+      kind: MetaKind.Pipe,
+      ref,
+      name,
+      nameExpr: null,
+      isStandalone,
+      decorator: null
+    };
   }
 };
-function getImportPath(expr) {
-  if (expr instanceof ExternalExpr2) {
-    return `${expr.value.moduleName}$${expr.value.name}`;
-  } else {
-    return null;
-  }
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters.mjs
-import ts9 from "typescript";
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util.mjs
-function isSymbolEqual(a, b) {
-  if (a.decl === b.decl) {
-    return true;
-  }
-  if (a.identifier === null || b.identifier === null) {
-    return false;
+function readBaseClass2(clazz, checker, reflector) {
+  if (!isNamedClassDeclaration(clazz)) {
+    return reflector.hasBaseClass(clazz) ? "dynamic" : null;
   }
-  return a.path === b.path && a.identifier === b.identifier;
-}
-function isReferenceEqual(a, b) {
-  if (!isSymbolEqual(a.symbol, b.symbol)) {
-    return false;
+  if (clazz.heritageClauses !== void 0) {
+    for (const clause of clazz.heritageClauses) {
+      if (clause.token === ts6.SyntaxKind.ExtendsKeyword) {
+        const baseExpr = clause.types[0].expression;
+        let symbol = checker.getSymbolAtLocation(baseExpr);
+        if (symbol === void 0) {
+          return "dynamic";
+        } else if (symbol.flags & ts6.SymbolFlags.Alias) {
+          symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (symbol.valueDeclaration !== void 0 && isNamedClassDeclaration(symbol.valueDeclaration)) {
+          return new Reference(symbol.valueDeclaration);
+        } else {
+          return "dynamic";
+        }
+      }
+    }
   }
-  return a.importPath === b.importPath;
-}
-function referenceEquality(a, b) {
-  return a === b;
+  return null;
 }
-function isArrayEqual(a, b, equalityTester = referenceEquality) {
-  if (a === null || b === null) {
-    return a === b;
+function readHostDirectivesType(checker, type, bestGuessOwningModule) {
+  if (!ts6.isTupleTypeNode(type) || type.elements.length === 0) {
+    return null;
   }
-  if (a.length !== b.length) {
-    return false;
+  const result = [];
+  for (const hostDirectiveType of type.elements) {
+    const { directive, inputs, outputs } = readMapType(hostDirectiveType, (type2) => type2);
+    if (directive) {
+      if (!ts6.isTypeQueryNode(directive)) {
+        throw new Error(`Expected TypeQueryNode: ${nodeDebugInfo(directive)}`);
+      }
+      result.push({
+        directive: extraReferenceFromTypeQuery(checker, directive, type, bestGuessOwningModule),
+        isForwardReference: false,
+        inputs: readMapType(inputs, readStringType),
+        outputs: readMapType(outputs, readStringType)
+      });
+    }
   }
-  return !a.some((item, index) => !equalityTester(item, b[index]));
+  return result.length > 0 ? result : null;
 }
-function isSetEqual(a, b, equalityTester = referenceEquality) {
-  if (a === null || b === null) {
-    return a === b;
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/inheritance.mjs
+function flattenInheritedDirectiveMetadata(reader, dir) {
+  const topMeta = reader.getDirectiveMetadata(dir);
+  if (topMeta === null) {
+    throw new Error(`Metadata not found for directive: ${dir.debugName}`);
   }
-  if (a.size !== b.size) {
-    return false;
+  if (topMeta.baseClass === null) {
+    return topMeta;
   }
-  for (const itemA of a) {
-    let found = false;
-    for (const itemB of b) {
-      if (equalityTester(itemA, itemB)) {
-        found = true;
-        break;
+  const coercedInputFields = /* @__PURE__ */ new Set();
+  const undeclaredInputFields = /* @__PURE__ */ new Set();
+  const restrictedInputFields = /* @__PURE__ */ new Set();
+  const stringLiteralInputFields = /* @__PURE__ */ new Set();
+  let isDynamic = false;
+  let inputs = ClassPropertyMapping.empty();
+  let outputs = ClassPropertyMapping.empty();
+  let isStructural = false;
+  const addMetadata = (meta) => {
+    if (meta.baseClass === "dynamic") {
+      isDynamic = true;
+    } else if (meta.baseClass !== null) {
+      const baseMeta = reader.getDirectiveMetadata(meta.baseClass);
+      if (baseMeta !== null) {
+        addMetadata(baseMeta);
+      } else {
+        isDynamic = true;
       }
     }
-    if (!found) {
-      return false;
+    isStructural = isStructural || meta.isStructural;
+    inputs = ClassPropertyMapping.merge(inputs, meta.inputs);
+    outputs = ClassPropertyMapping.merge(outputs, meta.outputs);
+    for (const coercedInputField of meta.coercedInputFields) {
+      coercedInputFields.add(coercedInputField);
     }
-  }
-  return true;
+    for (const undeclaredInputField of meta.undeclaredInputFields) {
+      undeclaredInputFields.add(undeclaredInputField);
+    }
+    for (const restrictedInputField of meta.restrictedInputFields) {
+      restrictedInputFields.add(restrictedInputField);
+    }
+    for (const field of meta.stringLiteralInputFields) {
+      stringLiteralInputFields.add(field);
+    }
+  };
+  addMetadata(topMeta);
+  return {
+    ...topMeta,
+    inputs,
+    outputs,
+    coercedInputFields,
+    undeclaredInputFields,
+    restrictedInputFields,
+    stringLiteralInputFields,
+    baseClass: isDynamic ? "dynamic" : null,
+    isStructural
+  };
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters.mjs
-function extractSemanticTypeParameters(node) {
-  if (!ts9.isClassDeclaration(node) || node.typeParameters === void 0) {
-    return null;
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/registry.mjs
+var LocalMetadataRegistry = class {
+  constructor() {
+    this.directives = /* @__PURE__ */ new Map();
+    this.ngModules = /* @__PURE__ */ new Map();
+    this.pipes = /* @__PURE__ */ new Map();
   }
-  return node.typeParameters.map((typeParam) => ({ hasGenericTypeBound: typeParam.constraint !== void 0 }));
-}
-function areTypeParametersEqual(current, previous) {
-  if (!isArrayEqual(current, previous, isTypeParameterEqual)) {
-    return false;
+  getDirectiveMetadata(ref) {
+    return this.directives.has(ref.node) ? this.directives.get(ref.node) : null;
   }
-  if (current !== null && current.some((typeParam) => typeParam.hasGenericTypeBound)) {
-    return false;
+  getNgModuleMetadata(ref) {
+    return this.ngModules.has(ref.node) ? this.ngModules.get(ref.node) : null;
   }
-  return true;
-}
-function isTypeParameterEqual(a, b) {
-  return a.hasGenericTypeBound === b.hasGenericTypeBound;
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/api.mjs
-var MetaKind;
-(function(MetaKind2) {
-  MetaKind2[MetaKind2["Directive"] = 0] = "Directive";
-  MetaKind2[MetaKind2["Pipe"] = 1] = "Pipe";
-  MetaKind2[MetaKind2["NgModule"] = 2] = "NgModule";
-})(MetaKind || (MetaKind = {}));
-var MatchSource;
-(function(MatchSource2) {
-  MatchSource2[MatchSource2["Selector"] = 0] = "Selector";
-  MatchSource2[MatchSource2["HostDirective"] = 1] = "HostDirective";
-})(MatchSource || (MatchSource = {}));
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/dts.mjs
-import ts11 from "typescript";
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/property_mapping.mjs
-var ClassPropertyMapping = class {
-  constructor(forwardMap) {
-    this.forwardMap = forwardMap;
-    this.reverseMap = reverseMapFromForwardMap(forwardMap);
+  getPipeMetadata(ref) {
+    return this.pipes.has(ref.node) ? this.pipes.get(ref.node) : null;
   }
-  static empty() {
-    return new ClassPropertyMapping(/* @__PURE__ */ new Map());
+  registerDirectiveMetadata(meta) {
+    this.directives.set(meta.ref.node, meta);
   }
-  static fromMappedObject(obj) {
-    const forwardMap = /* @__PURE__ */ new Map();
-    for (const classPropertyName of Object.keys(obj)) {
-      const value = obj[classPropertyName];
-      const bindingPropertyName = Array.isArray(value) ? value[0] : value;
-      const inputOrOutput = { classPropertyName, bindingPropertyName };
-      forwardMap.set(classPropertyName, inputOrOutput);
-    }
-    return new ClassPropertyMapping(forwardMap);
+  registerNgModuleMetadata(meta) {
+    this.ngModules.set(meta.ref.node, meta);
   }
-  static merge(a, b) {
-    const forwardMap = new Map(a.forwardMap.entries());
-    for (const [classPropertyName, inputOrOutput] of b.forwardMap) {
-      forwardMap.set(classPropertyName, inputOrOutput);
+  registerPipeMetadata(meta) {
+    this.pipes.set(meta.ref.node, meta);
+  }
+  getKnownDirectives() {
+    return this.directives.keys();
+  }
+};
+var CompoundMetadataRegistry = class {
+  constructor(registries) {
+    this.registries = registries;
+  }
+  registerDirectiveMetadata(meta) {
+    for (const registry of this.registries) {
+      registry.registerDirectiveMetadata(meta);
+    }
+  }
+  registerNgModuleMetadata(meta) {
+    for (const registry of this.registries) {
+      registry.registerNgModuleMetadata(meta);
     }
-    return new ClassPropertyMapping(forwardMap);
   }
-  get classPropertyNames() {
-    return Array.from(this.forwardMap.keys());
+  registerPipeMetadata(meta) {
+    for (const registry of this.registries) {
+      registry.registerPipeMetadata(meta);
+    }
   }
-  get propertyNames() {
-    return Array.from(this.reverseMap.keys());
+};
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/resource_registry.mjs
+var ResourceRegistry = class {
+  constructor() {
+    this.externalTemplateToComponentsMap = /* @__PURE__ */ new Map();
+    this.componentToTemplateMap = /* @__PURE__ */ new Map();
+    this.componentToStylesMap = /* @__PURE__ */ new Map();
+    this.externalStyleToComponentsMap = /* @__PURE__ */ new Map();
   }
-  hasBindingPropertyName(propertyName) {
-    return this.reverseMap.has(propertyName);
+  getComponentsWithTemplate(template) {
+    if (!this.externalTemplateToComponentsMap.has(template)) {
+      return /* @__PURE__ */ new Set();
+    }
+    return this.externalTemplateToComponentsMap.get(template);
   }
-  getByBindingPropertyName(propertyName) {
-    return this.reverseMap.has(propertyName) ? this.reverseMap.get(propertyName) : null;
+  registerResources(resources, component) {
+    if (resources.template !== null) {
+      this.registerTemplate(resources.template, component);
+    }
+    for (const style of resources.styles) {
+      this.registerStyle(style, component);
+    }
   }
-  getByClassPropertyName(classPropertyName) {
-    return this.forwardMap.has(classPropertyName) ? this.forwardMap.get(classPropertyName) : null;
+  registerTemplate(templateResource, component) {
+    const { path } = templateResource;
+    if (path !== null) {
+      if (!this.externalTemplateToComponentsMap.has(path)) {
+        this.externalTemplateToComponentsMap.set(path, /* @__PURE__ */ new Set());
+      }
+      this.externalTemplateToComponentsMap.get(path).add(component);
+    }
+    this.componentToTemplateMap.set(component, templateResource);
   }
-  toDirectMappedObject() {
-    const obj = {};
-    for (const [classPropertyName, inputOrOutput] of this.forwardMap) {
-      obj[classPropertyName] = inputOrOutput.bindingPropertyName;
+  getTemplate(component) {
+    if (!this.componentToTemplateMap.has(component)) {
+      return null;
     }
-    return obj;
+    return this.componentToTemplateMap.get(component);
   }
-  toJointMappedObject() {
-    const obj = {};
-    for (const [classPropertyName, inputOrOutput] of this.forwardMap) {
-      if (inputOrOutput.bindingPropertyName === classPropertyName) {
-        obj[classPropertyName] = inputOrOutput.bindingPropertyName;
-      } else {
-        obj[classPropertyName] = [inputOrOutput.bindingPropertyName, classPropertyName];
+  registerStyle(styleResource, component) {
+    const { path } = styleResource;
+    if (!this.componentToStylesMap.has(component)) {
+      this.componentToStylesMap.set(component, /* @__PURE__ */ new Set());
+    }
+    if (path !== null) {
+      if (!this.externalStyleToComponentsMap.has(path)) {
+        this.externalStyleToComponentsMap.set(path, /* @__PURE__ */ new Set());
       }
+      this.externalStyleToComponentsMap.get(path).add(component);
     }
-    return obj;
+    this.componentToStylesMap.get(component).add(styleResource);
   }
-  *[Symbol.iterator]() {
-    for (const [classPropertyName, inputOrOutput] of this.forwardMap.entries()) {
-      yield [classPropertyName, inputOrOutput.bindingPropertyName];
+  getStyles(component) {
+    if (!this.componentToStylesMap.has(component)) {
+      return /* @__PURE__ */ new Set();
     }
+    return this.componentToStylesMap.get(component);
   }
-};
-function reverseMapFromForwardMap(forwardMap) {
-  const reverseMap = /* @__PURE__ */ new Map();
-  for (const [_, inputOrOutput] of forwardMap) {
-    if (!reverseMap.has(inputOrOutput.bindingPropertyName)) {
-      reverseMap.set(inputOrOutput.bindingPropertyName, []);
+  getComponentsWithStyle(styleUrl) {
+    if (!this.externalStyleToComponentsMap.has(styleUrl)) {
+      return /* @__PURE__ */ new Set();
     }
-    reverseMap.get(inputOrOutput.bindingPropertyName).push(inputOrOutput);
+    return this.externalStyleToComponentsMap.get(styleUrl);
   }
-  return reverseMap;
-}
+};
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/util.mjs
-import ts10 from "typescript";
-function extractReferencesFromType(checker, def, bestGuessOwningModule) {
-  if (!ts10.isTupleTypeNode(def)) {
-    return [];
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/host_directives_resolver.mjs
+var EMPTY_ARRAY = [];
+var HostDirectivesResolver = class {
+  constructor(metaReader) {
+    this.metaReader = metaReader;
+    this.cache = /* @__PURE__ */ new Map();
   }
-  return def.elements.map((element) => {
-    if (!ts10.isTypeQueryNode(element)) {
-      throw new Error(`Expected TypeQueryNode: ${nodeDebugInfo(element)}`);
+  resolve(metadata) {
+    if (this.cache.has(metadata.ref.node)) {
+      return this.cache.get(metadata.ref.node);
     }
-    return extraReferenceFromTypeQuery(checker, element, def, bestGuessOwningModule);
-  });
-}
-function extraReferenceFromTypeQuery(checker, typeNode, origin, bestGuessOwningModule) {
-  const type = typeNode.exprName;
-  const { node, from } = reflectTypeEntityToDeclaration(type, checker);
-  if (!isNamedClassDeclaration(node)) {
-    throw new Error(`Expected named ClassDeclaration: ${nodeDebugInfo(node)}`);
+    const results = metadata.hostDirectives && metadata.hostDirectives.length > 0 ? this.walkHostDirectives(metadata.hostDirectives, []) : EMPTY_ARRAY;
+    this.cache.set(metadata.ref.node, results);
+    return results;
   }
-  if (from !== null && !from.startsWith(".")) {
-    return new Reference(node, { specifier: from, resolutionContext: origin.getSourceFile().fileName });
+  walkHostDirectives(directives, results) {
+    for (const current of directives) {
+      const hostMeta = flattenInheritedDirectiveMetadata(this.metaReader, current.directive);
+      if (hostMeta === null) {
+        throw new Error(`Could not resolve host directive metadata of ${current.directive.debugName}`);
+      }
+      if (hostMeta.hostDirectives) {
+        this.walkHostDirectives(hostMeta.hostDirectives, results);
+      }
+      results.push({
+        ...hostMeta,
+        matchSource: MatchSource.HostDirective,
+        inputs: this.filterMappings(hostMeta.inputs, current.inputs),
+        outputs: this.filterMappings(hostMeta.outputs, current.outputs)
+      });
+    }
+    return results;
   }
-  return new Reference(node, bestGuessOwningModule);
-}
-function readBooleanType(type) {
-  if (!ts10.isLiteralTypeNode(type)) {
-    return null;
+  filterMappings(source, allowedProperties) {
+    const result = {};
+    if (allowedProperties !== null) {
+      for (const publicName in allowedProperties) {
+        if (allowedProperties.hasOwnProperty(publicName)) {
+          const bindings = source.getByBindingPropertyName(publicName);
+          if (bindings !== null) {
+            for (const binding of bindings) {
+              result[binding.classPropertyName] = allowedProperties[publicName];
+            }
+          }
+        }
+      }
+    }
+    return ClassPropertyMapping.fromMappedObject(result);
   }
-  switch (type.literal.kind) {
-    case ts10.SyntaxKind.TrueKeyword:
-      return true;
-    case ts10.SyntaxKind.FalseKeyword:
-      return false;
-    default:
-      return null;
+};
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/diagnostics.mjs
+function makeDuplicateDeclarationError(node, data, kind) {
+  const context = [];
+  for (const decl of data) {
+    if (decl.rawDeclarations === null) {
+      continue;
+    }
+    const contextNode = decl.ref.getOriginForDiagnostics(decl.rawDeclarations, decl.ngModule.name);
+    context.push(makeRelatedInformation(contextNode, `'${node.name.text}' is listed in the declarations of the NgModule '${decl.ngModule.name.text}'.`));
   }
+  return makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_NOT_UNIQUE, node.name, `The ${kind} '${node.name.text}' is declared by more than one NgModule.`, context);
 }
-function readStringType(type) {
-  if (!ts10.isLiteralTypeNode(type) || !ts10.isStringLiteral(type.literal)) {
-    return null;
+function createValueHasWrongTypeError(node, value, messageText) {
+  var _a;
+  let chainedMessage;
+  let relatedInformation;
+  if (value instanceof DynamicValue) {
+    chainedMessage = "Value could not be determined statically.";
+    relatedInformation = traceDynamicValue(node, value);
+  } else if (value instanceof Reference) {
+    const target = value.debugName !== null ? `'${value.debugName}'` : "an anonymous declaration";
+    chainedMessage = `Value is a reference to ${target}.`;
+    const referenceNode = (_a = identifierOfNode(value.node)) != null ? _a : value.node;
+    relatedInformation = [makeRelatedInformation(referenceNode, "Reference is declared here.")];
+  } else {
+    chainedMessage = `Value is of type '${describeResolvedType(value)}'.`;
   }
-  return type.literal.text;
+  const chain = {
+    messageText,
+    category: ts7.DiagnosticCategory.Error,
+    code: 0,
+    next: [{
+      messageText: chainedMessage,
+      category: ts7.DiagnosticCategory.Message,
+      code: 0
+    }]
+  };
+  return new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, node, chain, relatedInformation);
 }
-function readMapType(type, valueTransform) {
-  if (!ts10.isTypeLiteralNode(type)) {
-    return {};
-  }
-  const obj = {};
-  type.members.forEach((member) => {
-    if (!ts10.isPropertySignature(member) || member.type === void 0 || member.name === void 0 || !ts10.isStringLiteral(member.name) && !ts10.isIdentifier(member.name)) {
-      return;
-    }
-    const value = valueTransform(member.type);
-    if (value === null) {
-      return null;
+function getProviderDiagnostics(providerClasses, providersDeclaration, registry) {
+  const diagnostics = [];
+  for (const provider of providerClasses) {
+    const injectableMeta = registry.getInjectableMeta(provider.node);
+    if (injectableMeta !== null) {
+      continue;
     }
-    obj[member.name.text] = value;
-  });
-  return obj;
-}
-function readStringArrayType(type) {
-  if (!ts10.isTupleTypeNode(type)) {
-    return [];
+    const contextNode = provider.getOriginForDiagnostics(providersDeclaration);
+    diagnostics.push(makeDiagnostic(ErrorCode.UNDECORATED_PROVIDER, contextNode, `The class '${provider.node.name.text}' cannot be created via dependency injection, as it does not have an Angular decorator. This will result in an error at runtime.
+
+Either add the @Injectable() decorator to '${provider.node.name.text}', or configure a different provider (such as a provider with 'useFactory').
+`, [makeRelatedInformation(provider.node, `'${provider.node.name.text}' is declared here.`)]));
   }
-  const res = [];
-  type.elements.forEach((el) => {
-    if (!ts10.isLiteralTypeNode(el) || !ts10.isStringLiteral(el.literal)) {
-      return;
-    }
-    res.push(el.literal.text);
-  });
-  return res;
+  return diagnostics;
 }
-function extractDirectiveTypeCheckMeta(node, inputs, reflector) {
-  const members = reflector.getMembersOfClass(node);
-  const staticMembers = members.filter((member) => member.isStatic);
-  const ngTemplateGuards = staticMembers.map(extractTemplateGuard).filter((guard) => guard !== null);
-  const hasNgTemplateContextGuard = staticMembers.some((member) => member.kind === ClassMemberKind.Method && member.name === "ngTemplateContextGuard");
-  const coercedInputFields = new Set(staticMembers.map(extractCoercedInput).filter((inputName) => inputName !== null));
-  const restrictedInputFields = /* @__PURE__ */ new Set();
-  const stringLiteralInputFields = /* @__PURE__ */ new Set();
-  const undeclaredInputFields = /* @__PURE__ */ new Set();
-  for (const classPropertyName of inputs.classPropertyNames) {
-    const field = members.find((member) => member.name === classPropertyName);
-    if (field === void 0 || field.node === null) {
-      undeclaredInputFields.add(classPropertyName);
+function getDirectiveDiagnostics(node, injectableRegistry, evaluator, reflector, scopeRegistry, strictInjectionParameters, kind) {
+  let diagnostics = [];
+  const addDiagnostics = (more) => {
+    if (more === null) {
+      return;
+    } else if (diagnostics === null) {
+      diagnostics = Array.isArray(more) ? more : [more];
+    } else if (Array.isArray(more)) {
+      diagnostics.push(...more);
+    } else {
+      diagnostics.push(more);
+    }
+  };
+  const duplicateDeclarations = scopeRegistry.getDuplicateDeclarations(node);
+  if (duplicateDeclarations !== null) {
+    addDiagnostics(makeDuplicateDeclarationError(node, duplicateDeclarations, kind));
+  }
+  addDiagnostics(checkInheritanceOfInjectable(node, injectableRegistry, reflector, evaluator, strictInjectionParameters, kind));
+  return diagnostics;
+}
+function validateHostDirectives(origin, hostDirectives, metaReader) {
+  const diagnostics = [];
+  for (const current of hostDirectives) {
+    const hostMeta = flattenInheritedDirectiveMetadata(metaReader, current.directive);
+    if (hostMeta === null) {
+      diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_INVALID, current.directive.getOriginForDiagnostics(origin), `${current.directive.debugName} must be a standalone directive to be used as a host directive`));
       continue;
     }
-    if (isRestricted(field.node)) {
-      restrictedInputFields.add(classPropertyName);
+    if (!hostMeta.isStandalone) {
+      diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_NOT_STANDALONE, current.directive.getOriginForDiagnostics(origin), `Host directive ${hostMeta.name} must be standalone`));
     }
-    if (field.nameNode !== null && ts10.isStringLiteral(field.nameNode)) {
-      stringLiteralInputFields.add(classPropertyName);
+    if (hostMeta.isComponent) {
+      diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_COMPONENT, current.directive.getOriginForDiagnostics(origin), `Host directive ${hostMeta.name} cannot be a component`));
     }
+    validateHostDirectiveMappings("input", current, hostMeta, origin, diagnostics);
+    validateHostDirectiveMappings("output", current, hostMeta, origin, diagnostics);
   }
-  const arity = reflector.getGenericArityOfClass(node);
-  return {
-    hasNgTemplateContextGuard,
-    ngTemplateGuards,
-    coercedInputFields,
-    restrictedInputFields,
-    stringLiteralInputFields,
-    undeclaredInputFields,
-    isGeneric: arity !== null && arity > 0
-  };
-}
-function isRestricted(node) {
-  const modifiers = getModifiers(node);
-  return modifiers !== void 0 && modifiers.some(({ kind }) => {
-    return kind === ts10.SyntaxKind.PrivateKeyword || kind === ts10.SyntaxKind.ProtectedKeyword || kind === ts10.SyntaxKind.ReadonlyKeyword;
-  });
+  return diagnostics;
 }
-function extractTemplateGuard(member) {
-  if (!member.name.startsWith("ngTemplateGuard_")) {
-    return null;
-  }
-  const inputName = afterUnderscore(member.name);
-  if (member.kind === ClassMemberKind.Property) {
-    let type = null;
-    if (member.type !== null && ts10.isLiteralTypeNode(member.type) && ts10.isStringLiteral(member.type.literal)) {
-      type = member.type.literal.text;
-    }
-    if (type !== "binding") {
-      return null;
+function validateHostDirectiveMappings(bindingType, hostDirectiveMeta, meta, origin, diagnostics) {
+  const className = meta.name;
+  const hostDirectiveMappings = bindingType === "input" ? hostDirectiveMeta.inputs : hostDirectiveMeta.outputs;
+  const existingBindings = bindingType === "input" ? meta.inputs : meta.outputs;
+  for (const publicName in hostDirectiveMappings) {
+    if (hostDirectiveMappings.hasOwnProperty(publicName)) {
+      if (!existingBindings.hasBindingPropertyName(publicName)) {
+        diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_UNDEFINED_BINDING, hostDirectiveMeta.directive.getOriginForDiagnostics(origin), `Directive ${className} does not have an ${bindingType} with a public name of ${publicName}.`));
+      }
+      const remappedPublicName = hostDirectiveMappings[publicName];
+      const bindingsForPublicName = existingBindings.getByBindingPropertyName(remappedPublicName);
+      if (bindingsForPublicName !== null) {
+        for (const binding of bindingsForPublicName) {
+          if (binding.bindingPropertyName !== publicName) {
+            diagnostics.push(makeDiagnostic(ErrorCode.HOST_DIRECTIVE_CONFLICTING_ALIAS, hostDirectiveMeta.directive.getOriginForDiagnostics(origin), `Cannot alias ${bindingType} ${publicName} of host directive ${className} to ${remappedPublicName}, because it already has a different ${bindingType} with the same public name.`));
+          }
+        }
+      }
     }
-    return { inputName, type };
-  } else if (member.kind === ClassMemberKind.Method) {
-    return { inputName, type: "invocation" };
-  } else {
-    return null;
   }
 }
-function extractCoercedInput(member) {
-  if (member.kind !== ClassMemberKind.Property || !member.name.startsWith("ngAcceptInputType_")) {
+function getUndecoratedClassWithAngularFeaturesDiagnostic(node) {
+  return makeDiagnostic(ErrorCode.UNDECORATED_CLASS_USING_ANGULAR_FEATURES, node.name, `Class is using Angular features but is not decorated. Please add an explicit Angular decorator.`);
+}
+function checkInheritanceOfInjectable(node, injectableRegistry, reflector, evaluator, strictInjectionParameters, kind) {
+  const classWithCtor = findInheritedCtor(node, injectableRegistry, reflector, evaluator);
+  if (classWithCtor === null || classWithCtor.isCtorValid) {
     return null;
   }
-  return afterUnderscore(member.name);
-}
-var CompoundMetadataReader = class {
-  constructor(readers) {
-    this.readers = readers;
+  if (!classWithCtor.isDecorated) {
+    return getInheritedUndecoratedCtorDiagnostic(node, classWithCtor.ref, kind);
   }
-  getDirectiveMetadata(node) {
-    for (const reader of this.readers) {
-      const meta = reader.getDirectiveMetadata(node);
-      if (meta !== null) {
-        return meta;
-      }
-    }
+  if (!strictInjectionParameters || isAbstractClassDeclaration(node)) {
     return null;
   }
-  getNgModuleMetadata(node) {
-    for (const reader of this.readers) {
-      const meta = reader.getNgModuleMetadata(node);
-      if (meta !== null) {
-        return meta;
-      }
-    }
+  return getInheritedInvalidCtorDiagnostic(node, classWithCtor.ref, kind);
+}
+function findInheritedCtor(node, injectableRegistry, reflector, evaluator) {
+  if (!reflector.isClass(node) || reflector.getConstructorParameters(node) !== null) {
     return null;
   }
-  getPipeMetadata(node) {
-    for (const reader of this.readers) {
-      const meta = reader.getPipeMetadata(node);
-      if (meta !== null) {
-        return meta;
+  let baseClass = readBaseClass(node, reflector, evaluator);
+  while (baseClass !== null) {
+    if (baseClass === "dynamic") {
+      return null;
+    }
+    const injectableMeta = injectableRegistry.getInjectableMeta(baseClass.node);
+    if (injectableMeta !== null) {
+      if (injectableMeta.ctorDeps !== null) {
+        return {
+          ref: baseClass,
+          isCtorValid: injectableMeta.ctorDeps !== "invalid",
+          isDecorated: true
+        };
+      }
+    } else {
+      const baseClassConstructorParams = reflector.getConstructorParameters(baseClass.node);
+      if (baseClassConstructorParams !== null) {
+        return {
+          ref: baseClass,
+          isCtorValid: baseClassConstructorParams.length === 0,
+          isDecorated: false
+        };
       }
     }
-    return null;
+    baseClass = readBaseClass(baseClass.node, reflector, evaluator);
   }
-};
-function afterUnderscore(str) {
-  const pos = str.indexOf("_");
-  if (pos === -1) {
-    throw new Error(`Expected '${str}' to contain '_'`);
-  }
-  return str.slice(pos + 1);
+  return null;
 }
-function hasInjectableFields(clazz, host) {
-  const members = host.getMembersOfClass(clazz);
-  return members.some(({ isStatic, name }) => isStatic && (name === "\u0275prov" || name === "\u0275fac"));
+function getInheritedInvalidCtorDiagnostic(node, baseClass, kind) {
+  const baseClassName = baseClass.debugName;
+  return makeDiagnostic(ErrorCode.INJECTABLE_INHERITS_INVALID_CONSTRUCTOR, node.name, `The ${kind.toLowerCase()} ${node.name.text} inherits its constructor from ${baseClassName}, but the latter has a constructor parameter that is not compatible with dependency injection. Either add an explicit constructor to ${node.name.text} or change ${baseClassName}'s constructor to use parameters that are valid for DI.`);
+}
+function getInheritedUndecoratedCtorDiagnostic(node, baseClass, kind) {
+  const baseClassName = baseClass.debugName;
+  const baseNeedsDecorator = kind === "Component" || kind === "Directive" ? "Directive" : "Injectable";
+  return makeDiagnostic(ErrorCode.DIRECTIVE_INHERITS_UNDECORATED_CTOR, node.name, `The ${kind.toLowerCase()} ${node.name.text} inherits its constructor from ${baseClassName}, but the latter does not have an Angular decorator of its own. Dependency injection will not be able to resolve the parameters of ${baseClassName}'s constructor. Either add a @${baseNeedsDecorator} decorator to ${baseClassName}, or add an explicit constructor to ${node.name.text}.`);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/dts.mjs
-var DtsMetadataReader = class {
-  constructor(checker, reflector) {
-    this.checker = checker;
-    this.reflector = reflector;
-  }
-  getNgModuleMetadata(ref) {
-    const clazz = ref.node;
-    const ngModuleDef = this.reflector.getMembersOfClass(clazz).find((member) => member.name === "\u0275mod" && member.isStatic);
-    if (ngModuleDef === void 0) {
-      return null;
-    } else if (ngModuleDef.type === null || !ts11.isTypeReferenceNode(ngModuleDef.type) || ngModuleDef.type.typeArguments === void 0 || ngModuleDef.type.typeArguments.length !== 4) {
-      return null;
-    }
-    const [_, declarationMetadata, importMetadata, exportMetadata] = ngModuleDef.type.typeArguments;
-    return {
-      kind: MetaKind.NgModule,
-      ref,
-      declarations: extractReferencesFromType(this.checker, declarationMetadata, ref.bestGuessOwningModule),
-      exports: extractReferencesFromType(this.checker, exportMetadata, ref.bestGuessOwningModule),
-      imports: extractReferencesFromType(this.checker, importMetadata, ref.bestGuessOwningModule),
-      schemas: [],
-      rawDeclarations: null,
-      rawImports: null,
-      rawExports: null,
-      decorator: null
-    };
-  }
-  getDirectiveMetadata(ref) {
-    var _a;
-    const clazz = ref.node;
-    const def = this.reflector.getMembersOfClass(clazz).find((field) => field.isStatic && (field.name === "\u0275cmp" || field.name === "\u0275dir"));
-    if (def === void 0) {
-      return null;
-    } else if (def.type === null || !ts11.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
-      return null;
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/evaluation.mjs
+import ts8 from "typescript";
+function resolveEnumValue(evaluator, metadata, field, enumSymbolName) {
+  let resolved = null;
+  if (metadata.has(field)) {
+    const expr = metadata.get(field);
+    const value = evaluator.evaluate(expr);
+    if (value instanceof EnumValue && isAngularCoreReference(value.enumRef, enumSymbolName)) {
+      resolved = value.resolved;
+    } else {
+      throw createValueHasWrongTypeError(expr, value, `${field} must be a member of ${enumSymbolName} enum from @angular/core`);
     }
-    const isComponent = def.name === "\u0275cmp";
-    const ctorParams = this.reflector.getConstructorParameters(clazz);
-    const isStructural = !isComponent && ctorParams !== null && ctorParams.some((param) => {
-      return param.typeValueReference.kind === 1 && param.typeValueReference.moduleName === "@angular/core" && param.typeValueReference.importedName === "TemplateRef";
-    });
-    const isStandalone = def.type.typeArguments.length > 7 && ((_a = readBooleanType(def.type.typeArguments[7])) != null ? _a : false);
-    const inputs = ClassPropertyMapping.fromMappedObject(readMapType(def.type.typeArguments[3], readStringType));
-    const outputs = ClassPropertyMapping.fromMappedObject(readMapType(def.type.typeArguments[4], readStringType));
-    const hostDirectives = def.type.typeArguments.length > 8 ? readHostDirectivesType(this.checker, def.type.typeArguments[8], ref.bestGuessOwningModule) : null;
-    return {
-      kind: MetaKind.Directive,
-      matchSource: MatchSource.Selector,
-      ref,
-      name: clazz.name.text,
-      isComponent,
-      selector: readStringType(def.type.typeArguments[1]),
-      exportAs: readStringArrayType(def.type.typeArguments[2]),
-      inputs,
-      outputs,
-      hostDirectives,
-      queries: readStringArrayType(def.type.typeArguments[5]),
-      ...extractDirectiveTypeCheckMeta(clazz, inputs, this.reflector),
-      baseClass: readBaseClass2(clazz, this.checker, this.reflector),
-      isPoisoned: false,
-      isStructural,
-      animationTriggerNames: null,
-      isStandalone,
-      imports: null,
-      schemas: null,
-      decorator: null
-    };
   }
-  getPipeMetadata(ref) {
-    var _a;
-    const def = this.reflector.getMembersOfClass(ref.node).find((field) => field.isStatic && field.name === "\u0275pipe");
-    if (def === void 0) {
-      return null;
-    } else if (def.type === null || !ts11.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
-      return null;
-    }
-    const type = def.type.typeArguments[1];
-    if (!ts11.isLiteralTypeNode(type) || !ts11.isStringLiteral(type.literal)) {
-      return null;
-    }
-    const name = type.literal.text;
-    const isStandalone = def.type.typeArguments.length > 2 && ((_a = readBooleanType(def.type.typeArguments[2])) != null ? _a : false);
-    return {
-      kind: MetaKind.Pipe,
-      ref,
-      name,
-      nameExpr: null,
-      isStandalone,
-      decorator: null
-    };
+  return resolved;
+}
+function isStringArray(resolvedValue) {
+  return Array.isArray(resolvedValue) && resolvedValue.every((elem) => typeof elem === "string");
+}
+function resolveLiteral(decorator, literalCache) {
+  if (literalCache.has(decorator)) {
+    return literalCache.get(decorator);
   }
-};
-function readBaseClass2(clazz, checker, reflector) {
-  if (!isNamedClassDeclaration(clazz)) {
-    return reflector.hasBaseClass(clazz) ? "dynamic" : null;
+  if (decorator.args === null || decorator.args.length !== 1) {
+    throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @${decorator.name} decorator`);
   }
-  if (clazz.heritageClauses !== void 0) {
-    for (const clause of clazz.heritageClauses) {
-      if (clause.token === ts11.SyntaxKind.ExtendsKeyword) {
-        const baseExpr = clause.types[0].expression;
-        let symbol = checker.getSymbolAtLocation(baseExpr);
-        if (symbol === void 0) {
-          return "dynamic";
-        } else if (symbol.flags & ts11.SymbolFlags.Alias) {
-          symbol = checker.getAliasedSymbol(symbol);
-        }
-        if (symbol.valueDeclaration !== void 0 && isNamedClassDeclaration(symbol.valueDeclaration)) {
-          return new Reference(symbol.valueDeclaration);
-        } else {
-          return "dynamic";
-        }
-      }
-    }
+  const meta = unwrapExpression(decorator.args[0]);
+  if (!ts8.isObjectLiteralExpression(meta)) {
+    throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `Decorator argument must be literal.`);
   }
-  return null;
+  literalCache.set(decorator, meta);
+  return meta;
 }
-function readHostDirectivesType(checker, type, bestGuessOwningModule) {
-  if (!ts11.isTupleTypeNode(type) || type.elements.length === 0) {
-    return null;
-  }
-  const result = [];
-  for (const hostDirectiveType of type.elements) {
-    const { directive, inputs, outputs } = readMapType(hostDirectiveType, (type2) => type2);
-    if (directive) {
-      if (!ts11.isTypeQueryNode(directive)) {
-        throw new Error(`Expected TypeQueryNode: ${nodeDebugInfo(directive)}`);
-      }
-      result.push({
-        directive: extraReferenceFromTypeQuery(checker, directive, type, bestGuessOwningModule),
-        isForwardReference: false,
-        inputs: readMapType(inputs, readStringType),
-        outputs: readMapType(outputs, readStringType)
-      });
-    }
-  }
-  return result.length > 0 ? result : null;
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/factory.mjs
+import { compileDeclareFactoryFunction, compileFactoryFunction } from "@angular/compiler";
+function compileNgFactoryDefField(metadata) {
+  const res = compileFactoryFunction(metadata);
+  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
+}
+function compileDeclareFactory(metadata) {
+  const res = compileDeclareFactoryFunction(metadata);
+  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/inheritance.mjs
-function flattenInheritedDirectiveMetadata(reader, dir) {
-  const topMeta = reader.getDirectiveMetadata(dir);
-  if (topMeta === null) {
-    throw new Error(`Metadata not found for directive: ${dir.debugName}`);
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/injectable_registry.mjs
+var InjectableClassRegistry = class {
+  constructor(host, isCore) {
+    this.host = host;
+    this.isCore = isCore;
+    this.classes = /* @__PURE__ */ new Map();
   }
-  if (topMeta.baseClass === null) {
-    return topMeta;
+  registerInjectable(declaration, meta) {
+    this.classes.set(declaration, meta);
   }
-  const coercedInputFields = /* @__PURE__ */ new Set();
-  const undeclaredInputFields = /* @__PURE__ */ new Set();
-  const restrictedInputFields = /* @__PURE__ */ new Set();
-  const stringLiteralInputFields = /* @__PURE__ */ new Set();
-  let isDynamic = false;
-  let inputs = ClassPropertyMapping.empty();
-  let outputs = ClassPropertyMapping.empty();
-  let isStructural = false;
-  const addMetadata = (meta) => {
-    if (meta.baseClass === "dynamic") {
-      isDynamic = true;
-    } else if (meta.baseClass !== null) {
-      const baseMeta = reader.getDirectiveMetadata(meta.baseClass);
-      if (baseMeta !== null) {
-        addMetadata(baseMeta);
-      } else {
-        isDynamic = true;
-      }
-    }
-    isStructural = isStructural || meta.isStructural;
-    inputs = ClassPropertyMapping.merge(inputs, meta.inputs);
-    outputs = ClassPropertyMapping.merge(outputs, meta.outputs);
-    for (const coercedInputField of meta.coercedInputFields) {
-      coercedInputFields.add(coercedInputField);
-    }
-    for (const undeclaredInputField of meta.undeclaredInputFields) {
-      undeclaredInputFields.add(undeclaredInputField);
-    }
-    for (const restrictedInputField of meta.restrictedInputFields) {
-      restrictedInputFields.add(restrictedInputField);
+  getInjectableMeta(declaration) {
+    if (this.classes.has(declaration)) {
+      return this.classes.get(declaration);
     }
-    for (const field of meta.stringLiteralInputFields) {
-      stringLiteralInputFields.add(field);
+    if (!hasInjectableFields(declaration, this.host)) {
+      return null;
     }
-  };
-  addMetadata(topMeta);
-  return {
-    ...topMeta,
-    inputs,
-    outputs,
-    coercedInputFields,
-    undeclaredInputFields,
-    restrictedInputFields,
-    stringLiteralInputFields,
-    baseClass: isDynamic ? "dynamic" : null,
-    isStructural
-  };
-}
+    const ctorDeps = getConstructorDependencies(declaration, this.host, this.isCore);
+    const meta = {
+      ctorDeps: unwrapConstructorDependencies(ctorDeps)
+    };
+    this.classes.set(declaration, meta);
+    return meta;
+  }
+};
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/registry.mjs
-var LocalMetadataRegistry = class {
-  constructor() {
-    this.directives = /* @__PURE__ */ new Map();
-    this.ngModules = /* @__PURE__ */ new Map();
-    this.pipes = /* @__PURE__ */ new Map();
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/metadata.mjs
+import { FunctionExpr, LiteralArrayExpr, LiteralExpr as LiteralExpr2, literalMap, ReturnStatement, WrappedNodeExpr as WrappedNodeExpr3 } from "@angular/compiler";
+import ts9 from "typescript";
+function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompiler, angularDecoratorTransform = (dec) => dec) {
+  if (!reflection.isClass(clazz)) {
+    return null;
   }
-  getDirectiveMetadata(ref) {
-    return this.directives.has(ref.node) ? this.directives.get(ref.node) : null;
+  const id = reflection.getAdjacentNameOfClass(clazz);
+  const classDecorators = reflection.getDecoratorsOfDeclaration(clazz);
+  if (classDecorators === null) {
+    return null;
   }
-  getNgModuleMetadata(ref) {
-    return this.ngModules.has(ref.node) ? this.ngModules.get(ref.node) : null;
+  const ngClassDecorators = classDecorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(angularDecoratorTransform(decorator), annotateForClosureCompiler)).map((decorator) => removeIdentifierReferences(decorator, id.text));
+  if (ngClassDecorators.length === 0) {
+    return null;
   }
-  getPipeMetadata(ref) {
-    return this.pipes.has(ref.node) ? this.pipes.get(ref.node) : null;
+  const metaDecorators = new WrappedNodeExpr3(ts9.factory.createArrayLiteralExpression(ngClassDecorators));
+  let metaCtorParameters = null;
+  const classCtorParameters = reflection.getConstructorParameters(clazz);
+  if (classCtorParameters !== null) {
+    const ctorParameters = classCtorParameters.map((param) => ctorParameterToMetadata(param, isCore));
+    metaCtorParameters = new FunctionExpr([], [
+      new ReturnStatement(new LiteralArrayExpr(ctorParameters))
+    ]);
   }
-  registerDirectiveMetadata(meta) {
-    this.directives.set(meta.ref.node, meta);
+  let metaPropDecorators = null;
+  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && member.decorators !== null && member.decorators.length > 0);
+  const duplicateDecoratedMemberNames = classMembers.map((member) => member.name).filter((name, i, arr) => arr.indexOf(name) < i);
+  if (duplicateDecoratedMemberNames.length > 0) {
+    throw new Error(`Duplicate decorated properties found on class '${clazz.name.text}': ` + duplicateDecoratedMemberNames.join(", "));
   }
-  registerNgModuleMetadata(meta) {
-    this.ngModules.set(meta.ref.node, meta);
+  const decoratedMembers = classMembers.map((member) => {
+    var _a;
+    return classMemberToMetadata((_a = member.nameNode) != null ? _a : member.name, member.decorators, isCore);
+  });
+  if (decoratedMembers.length > 0) {
+    metaPropDecorators = new WrappedNodeExpr3(ts9.factory.createObjectLiteralExpression(decoratedMembers));
   }
-  registerPipeMetadata(meta) {
-    this.pipes.set(meta.ref.node, meta);
+  return {
+    type: new WrappedNodeExpr3(id),
+    decorators: metaDecorators,
+    ctorParameters: metaCtorParameters,
+    propDecorators: metaPropDecorators
+  };
+}
+function ctorParameterToMetadata(param, isCore) {
+  const type = param.typeValueReference.kind !== 2 ? valueReferenceToExpression(param.typeValueReference) : new LiteralExpr2(void 0);
+  const mapEntries = [
+    { key: "type", value: type, quoted: false }
+  ];
+  if (param.decorators !== null) {
+    const ngDecorators = param.decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(decorator));
+    const value = new WrappedNodeExpr3(ts9.factory.createArrayLiteralExpression(ngDecorators));
+    mapEntries.push({ key: "decorators", value, quoted: false });
   }
-  getKnownDirectives() {
-    return this.directives.keys();
+  return literalMap(mapEntries);
+}
+function classMemberToMetadata(name, decorators, isCore) {
+  const ngDecorators = decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(decorator));
+  const decoratorMeta = ts9.factory.createArrayLiteralExpression(ngDecorators);
+  return ts9.factory.createPropertyAssignment(name, decoratorMeta);
+}
+function decoratorToMetadata(decorator, wrapFunctionsInParens) {
+  if (decorator.identifier === null) {
+    throw new Error("Illegal state: synthesized decorator cannot be emitted in class metadata.");
+  }
+  const properties = [
+    ts9.factory.createPropertyAssignment("type", decorator.identifier)
+  ];
+  if (decorator.args !== null && decorator.args.length > 0) {
+    const args = decorator.args.map((arg) => {
+      return wrapFunctionsInParens ? wrapFunctionExpressionsInParens(arg) : arg;
+    });
+    properties.push(ts9.factory.createPropertyAssignment("args", ts9.factory.createArrayLiteralExpression(args)));
+  }
+  return ts9.factory.createObjectLiteralExpression(properties, true);
+}
+function isAngularDecorator2(decorator, isCore) {
+  return isCore || decorator.import !== null && decorator.import.from === "@angular/core";
+}
+function removeIdentifierReferences(node, name) {
+  const result = ts9.transform(node, [(context) => (root) => ts9.visitNode(root, function walk(current) {
+    return ts9.isIdentifier(current) && current.text === name ? ts9.factory.createIdentifier(current.text) : ts9.visitEachChild(current, walk, context);
+  })]);
+  return result.transformed[0];
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/references_registry.mjs
+var NoopReferencesRegistry = class {
+  add(source, ...references) {
   }
 };
-var CompoundMetadataRegistry = class {
-  constructor(registries) {
-    this.registries = registries;
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/schema.mjs
+import { CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA } from "@angular/compiler";
+function extractSchemas(rawExpr, evaluator, context) {
+  const schemas = [];
+  const result = evaluator.evaluate(rawExpr);
+  if (!Array.isArray(result)) {
+    throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array`);
   }
-  registerDirectiveMetadata(meta) {
-    for (const registry of this.registries) {
-      registry.registerDirectiveMetadata(meta);
+  for (const schemaRef of result) {
+    if (!(schemaRef instanceof Reference)) {
+      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
     }
-  }
-  registerNgModuleMetadata(meta) {
-    for (const registry of this.registries) {
-      registry.registerNgModuleMetadata(meta);
+    const id = schemaRef.getIdentityIn(schemaRef.node.getSourceFile());
+    if (id === null || schemaRef.ownedByModuleGuess !== "@angular/core") {
+      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
     }
-  }
-  registerPipeMetadata(meta) {
-    for (const registry of this.registries) {
-      registry.registerPipeMetadata(meta);
+    switch (id.text) {
+      case "CUSTOM_ELEMENTS_SCHEMA":
+        schemas.push(CUSTOM_ELEMENTS_SCHEMA);
+        break;
+      case "NO_ERRORS_SCHEMA":
+        schemas.push(NO_ERRORS_SCHEMA);
+        break;
+      default:
+        throw createValueHasWrongTypeError(rawExpr, schemaRef, `'${schemaRef.debugName}' is not a valid ${context} schema`);
     }
   }
+  return schemas;
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
+import { compileClassMetadata as compileClassMetadata3, compileComponentFromMetadata, compileDeclareClassMetadata as compileDeclareClassMetadata3, compileDeclareComponentFromMetadata, CssSelector as CssSelector2, DEFAULT_INTERPOLATION_CONFIG as DEFAULT_INTERPOLATION_CONFIG2, DomElementSchemaRegistry, FactoryTarget as FactoryTarget3, makeBindingParser as makeBindingParser2, R3TargetBinder, R3TemplateDependencyKind, SelectorMatcher as SelectorMatcher2, ViewEncapsulation, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
+import ts24 from "typescript";
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.mjs
+import ts10 from "typescript";
+var SemanticSymbol = class {
+  constructor(decl) {
+    this.decl = decl;
+    this.path = absoluteFromSourceFile(decl.getSourceFile());
+    this.identifier = getSymbolIdentifier(decl);
+  }
 };
-var InjectableClassRegistry = class {
-  constructor(host) {
-    this.host = host;
-    this.classes = /* @__PURE__ */ new Set();
+function getSymbolIdentifier(decl) {
+  if (!ts10.isSourceFile(decl.parent)) {
+    return null;
   }
-  registerInjectable(declaration) {
-    this.classes.add(declaration);
+  return decl.name.text;
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/graph.mjs
+import { ExternalExpr as ExternalExpr2 } from "@angular/compiler";
+var OpaqueSymbol = class extends SemanticSymbol {
+  isPublicApiAffected() {
+    return false;
   }
-  isInjectable(declaration) {
-    return this.classes.has(declaration) || hasInjectableFields(declaration, this.host);
+  isTypeCheckApiAffected() {
+    return false;
   }
 };
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/resource_registry.mjs
-var ResourceRegistry = class {
+var SemanticDepGraph = class {
   constructor() {
-    this.externalTemplateToComponentsMap = /* @__PURE__ */ new Map();
-    this.componentToTemplateMap = /* @__PURE__ */ new Map();
-    this.componentToStylesMap = /* @__PURE__ */ new Map();
-    this.externalStyleToComponentsMap = /* @__PURE__ */ new Map();
+    this.files = /* @__PURE__ */ new Map();
+    this.symbolByDecl = /* @__PURE__ */ new Map();
   }
-  getComponentsWithTemplate(template) {
-    if (!this.externalTemplateToComponentsMap.has(template)) {
-      return /* @__PURE__ */ new Set();
+  registerSymbol(symbol) {
+    this.symbolByDecl.set(symbol.decl, symbol);
+    if (symbol.identifier !== null) {
+      if (!this.files.has(symbol.path)) {
+        this.files.set(symbol.path, /* @__PURE__ */ new Map());
+      }
+      this.files.get(symbol.path).set(symbol.identifier, symbol);
+    }
+  }
+  getEquivalentSymbol(symbol) {
+    let previousSymbol = this.getSymbolByDecl(symbol.decl);
+    if (previousSymbol === null && symbol.identifier !== null) {
+      previousSymbol = this.getSymbolByName(symbol.path, symbol.identifier);
+    }
+    return previousSymbol;
+  }
+  getSymbolByName(path, identifier) {
+    if (!this.files.has(path)) {
+      return null;
+    }
+    const file = this.files.get(path);
+    if (!file.has(identifier)) {
+      return null;
     }
-    return this.externalTemplateToComponentsMap.get(template);
+    return file.get(identifier);
   }
-  registerResources(resources, component) {
-    if (resources.template !== null) {
-      this.registerTemplate(resources.template, component);
+  getSymbolByDecl(decl) {
+    if (!this.symbolByDecl.has(decl)) {
+      return null;
     }
-    for (const style of resources.styles) {
-      this.registerStyle(style, component);
+    return this.symbolByDecl.get(decl);
+  }
+};
+var SemanticDepGraphUpdater = class {
+  constructor(priorGraph) {
+    this.priorGraph = priorGraph;
+    this.newGraph = new SemanticDepGraph();
+    this.opaqueSymbols = /* @__PURE__ */ new Map();
+  }
+  registerSymbol(symbol) {
+    this.newGraph.registerSymbol(symbol);
+  }
+  finalize() {
+    if (this.priorGraph === null) {
+      return {
+        needsEmit: /* @__PURE__ */ new Set(),
+        needsTypeCheckEmit: /* @__PURE__ */ new Set(),
+        newGraph: this.newGraph
+      };
     }
+    const needsEmit = this.determineInvalidatedFiles(this.priorGraph);
+    const needsTypeCheckEmit = this.determineInvalidatedTypeCheckFiles(this.priorGraph);
+    return {
+      needsEmit,
+      needsTypeCheckEmit,
+      newGraph: this.newGraph
+    };
   }
-  registerTemplate(templateResource, component) {
-    const { path } = templateResource;
-    if (path !== null) {
-      if (!this.externalTemplateToComponentsMap.has(path)) {
-        this.externalTemplateToComponentsMap.set(path, /* @__PURE__ */ new Set());
+  determineInvalidatedFiles(priorGraph) {
+    const isPublicApiAffected = /* @__PURE__ */ new Set();
+    for (const symbol of this.newGraph.symbolByDecl.values()) {
+      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+      if (previousSymbol === null || symbol.isPublicApiAffected(previousSymbol)) {
+        isPublicApiAffected.add(symbol);
       }
-      this.externalTemplateToComponentsMap.get(path).add(component);
     }
-    this.componentToTemplateMap.set(component, templateResource);
-  }
-  getTemplate(component) {
-    if (!this.componentToTemplateMap.has(component)) {
-      return null;
+    const needsEmit = /* @__PURE__ */ new Set();
+    for (const symbol of this.newGraph.symbolByDecl.values()) {
+      if (symbol.isEmitAffected === void 0) {
+        continue;
+      }
+      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+      if (previousSymbol === null || symbol.isEmitAffected(previousSymbol, isPublicApiAffected)) {
+        needsEmit.add(symbol.path);
+      }
     }
-    return this.componentToTemplateMap.get(component);
+    return needsEmit;
   }
-  registerStyle(styleResource, component) {
-    const { path } = styleResource;
-    if (!this.componentToStylesMap.has(component)) {
-      this.componentToStylesMap.set(component, /* @__PURE__ */ new Set());
+  determineInvalidatedTypeCheckFiles(priorGraph) {
+    const isTypeCheckApiAffected = /* @__PURE__ */ new Set();
+    for (const symbol of this.newGraph.symbolByDecl.values()) {
+      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+      if (previousSymbol === null || symbol.isTypeCheckApiAffected(previousSymbol)) {
+        isTypeCheckApiAffected.add(symbol);
+      }
     }
-    if (path !== null) {
-      if (!this.externalStyleToComponentsMap.has(path)) {
-        this.externalStyleToComponentsMap.set(path, /* @__PURE__ */ new Set());
+    const needsTypeCheckEmit = /* @__PURE__ */ new Set();
+    for (const symbol of this.newGraph.symbolByDecl.values()) {
+      if (symbol.isTypeCheckBlockAffected === void 0) {
+        continue;
+      }
+      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+      if (previousSymbol === null || symbol.isTypeCheckBlockAffected(previousSymbol, isTypeCheckApiAffected)) {
+        needsTypeCheckEmit.add(symbol.path);
       }
-      this.externalStyleToComponentsMap.get(path).add(component);
     }
-    this.componentToStylesMap.get(component).add(styleResource);
+    return needsTypeCheckEmit;
   }
-  getStyles(component) {
-    if (!this.componentToStylesMap.has(component)) {
-      return /* @__PURE__ */ new Set();
+  getSemanticReference(decl, expr) {
+    return {
+      symbol: this.getSymbol(decl),
+      importPath: getImportPath(expr)
+    };
+  }
+  getSymbol(decl) {
+    const symbol = this.newGraph.getSymbolByDecl(decl);
+    if (symbol === null) {
+      return this.getOpaqueSymbol(decl);
     }
-    return this.componentToStylesMap.get(component);
+    return symbol;
   }
-  getComponentsWithStyle(styleUrl) {
-    if (!this.externalStyleToComponentsMap.has(styleUrl)) {
-      return /* @__PURE__ */ new Set();
+  getOpaqueSymbol(decl) {
+    if (this.opaqueSymbols.has(decl)) {
+      return this.opaqueSymbols.get(decl);
     }
-    return this.externalStyleToComponentsMap.get(styleUrl);
+    const symbol = new OpaqueSymbol(decl);
+    this.opaqueSymbols.set(decl, symbol);
+    return symbol;
   }
 };
+function getImportPath(expr) {
+  if (expr instanceof ExternalExpr2) {
+    return `${expr.value.moduleName}$${expr.value.name}`;
+  } else {
+    return null;
+  }
+}
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/host_directives_resolver.mjs
-var EMPTY_ARRAY = [];
-var HostDirectivesResolver = class {
-  constructor(metaReader) {
-    this.metaReader = metaReader;
-    this.cache = /* @__PURE__ */ new Map();
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters.mjs
+import ts11 from "typescript";
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util.mjs
+function isSymbolEqual(a, b) {
+  if (a.decl === b.decl) {
+    return true;
   }
-  resolve(metadata) {
-    if (this.cache.has(metadata.ref.node)) {
-      return this.cache.get(metadata.ref.node);
-    }
-    const results = metadata.hostDirectives && metadata.hostDirectives.length > 0 ? this.walkHostDirectives(metadata.hostDirectives, []) : EMPTY_ARRAY;
-    this.cache.set(metadata.ref.node, results);
-    return results;
+  if (a.identifier === null || b.identifier === null) {
+    return false;
   }
-  walkHostDirectives(directives, results) {
-    for (const current of directives) {
-      const hostMeta = flattenInheritedDirectiveMetadata(this.metaReader, current.directive);
-      if (hostMeta === null) {
-        throw new Error(`Could not resolve host directive metadata of ${current.directive.debugName}`);
-      }
-      if (hostMeta.hostDirectives) {
-        this.walkHostDirectives(hostMeta.hostDirectives, results);
-      }
-      results.push({
-        ...hostMeta,
-        matchSource: MatchSource.HostDirective,
-        inputs: this.filterMappings(hostMeta.inputs, current.inputs),
-        outputs: this.filterMappings(hostMeta.outputs, current.outputs)
-      });
-    }
-    return results;
+  return a.path === b.path && a.identifier === b.identifier;
+}
+function isReferenceEqual(a, b) {
+  if (!isSymbolEqual(a.symbol, b.symbol)) {
+    return false;
   }
-  filterMappings(source, allowedProperties) {
-    const result = {};
-    if (allowedProperties !== null) {
-      for (const publicName in allowedProperties) {
-        if (allowedProperties.hasOwnProperty(publicName)) {
-          const bindings = source.getByBindingPropertyName(publicName);
-          if (bindings !== null) {
-            for (const binding of bindings) {
-              result[binding.classPropertyName] = allowedProperties[publicName];
-            }
-          }
-        }
+  return a.importPath === b.importPath;
+}
+function referenceEquality(a, b) {
+  return a === b;
+}
+function isArrayEqual(a, b, equalityTester = referenceEquality) {
+  if (a === null || b === null) {
+    return a === b;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  return !a.some((item, index) => !equalityTester(item, b[index]));
+}
+function isSetEqual(a, b, equalityTester = referenceEquality) {
+  if (a === null || b === null) {
+    return a === b;
+  }
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const itemA of a) {
+    let found = false;
+    for (const itemB of b) {
+      if (equalityTester(itemA, itemB)) {
+        found = true;
+        break;
       }
     }
-    return ClassPropertyMapping.fromMappedObject(result);
+    if (!found) {
+      return false;
+    }
   }
-};
+  return true;
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters.mjs
+function extractSemanticTypeParameters(node) {
+  if (!ts11.isClassDeclaration(node) || node.typeParameters === void 0) {
+    return null;
+  }
+  return node.typeParameters.map((typeParam) => ({ hasGenericTypeBound: typeParam.constraint !== void 0 }));
+}
+function areTypeParametersEqual(current, previous) {
+  if (!isArrayEqual(current, previous, isTypeParameterEqual)) {
+    return false;
+  }
+  if (current !== null && current.some((typeParam) => typeParam.hasGenericTypeBound)) {
+    return false;
+  }
+  return true;
+}
+function isTypeParameterEqual(a, b) {
+  return a.hasGenericTypeBound === b.hasGenericTypeBound;
+}
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/api.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/api.mjs
 var ComponentScopeKind;
 (function(ComponentScopeKind2) {
   ComponentScopeKind2[ComponentScopeKind2["NgModule"] = 0] = "NgModule";
   ComponentScopeKind2[ComponentScopeKind2["Standalone"] = 1] = "Standalone";
 })(ComponentScopeKind || (ComponentScopeKind = {}));
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/component_scope.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/component_scope.mjs
 var CompoundComponentScopeReader = class {
   constructor(readers) {
     this.readers = readers;
@@ -2660,7 +2727,7 @@ var CompoundComponentScopeReader = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/dependency.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/dependency.mjs
 var MetadataDtsModuleScopeResolver = class {
   constructor(dtsMetaReader, aliasingHost) {
     this.dtsMetaReader = dtsMetaReader;
@@ -2736,11 +2803,11 @@ var MetadataDtsModuleScopeResolver = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/local.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/local.mjs
 import { ExternalExpr as ExternalExpr3 } from "@angular/compiler";
 import ts12 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/util.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/util.mjs
 function getDiagnosticNode(ref, rawExpr) {
   return rawExpr !== null ? ref.getOriginForDiagnostics(rawExpr) : ref.node.name;
 }
@@ -2763,7 +2830,7 @@ function makeUnknownComponentImportDiagnostic(ref, rawExpr) {
   return makeDiagnostic(ErrorCode.COMPONENT_UNKNOWN_IMPORT, getDiagnosticNode(ref, rawExpr), `Component imports must be standalone components, directives, pipes, or must be NgModules.`);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/local.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/local.mjs
 var LocalModuleScopeRegistry = class {
   constructor(localReader, fullReader, dependencyScopeReader, refEmitter, aliasingHost) {
     this.localReader = localReader;
@@ -3102,7 +3169,7 @@ function reexportCollision(module, refA, refB) {
   ]);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/typecheck.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/typecheck.mjs
 import { CssSelector, SelectorMatcher } from "@angular/compiler";
 import ts13 from "typescript";
 var TypeCheckScopeRegistry = class {
@@ -3165,7 +3232,7 @@ var TypeCheckScopeRegistry = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/api.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/api.mjs
 var CompilationMode;
 (function(CompilationMode2) {
   CompilationMode2[CompilationMode2["FULL"] = 0] = "FULL";
@@ -3183,7 +3250,7 @@ var HandlerFlags;
   HandlerFlags2[HandlerFlags2["FULL_INHERITANCE"] = 1] = "FULL_INHERITANCE";
 })(HandlerFlags || (HandlerFlags = {}));
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/alias.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/alias.mjs
 import ts14 from "typescript";
 function aliasTransformFactory(exportStatements) {
   return (context) => {
@@ -3201,10 +3268,10 @@ function aliasTransformFactory(exportStatements) {
   };
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
 import ts15 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/trait.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/trait.mjs
 var TraitState;
 (function(TraitState2) {
   TraitState2[TraitState2["Pending"] = 0] = "Pending";
@@ -3259,7 +3326,7 @@ var TraitImpl = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
 var TraitCompiler = class {
   constructor(handlers, reflector, perf, incrementalBuild, compileNonExportedClasses, compilationMode, dtsTransforms, semanticDepGraphUpdater, sourceFileTypeIdentifier) {
     this.handlers = handlers;
@@ -3703,10 +3770,10 @@ function containsErrors(diagnostics) {
   return diagnostics !== null && diagnostics.some((diag) => diag.category === ts15.DiagnosticCategory.Error);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
 import ts17 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/utils.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/utils.mjs
 import ts16 from "typescript";
 function addImports(importManager, sf, extraStatements = []) {
   const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
@@ -3734,7 +3801,7 @@ function isImportStatement(stmt) {
   return ts16.isImportDeclaration(stmt) || ts16.isImportEqualsDeclaration(stmt) || ts16.isNamespaceImport(stmt);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
 var DtsTransformRegistry = class {
   constructor() {
     this.ivyDeclarationTransforms = /* @__PURE__ */ new Map();
@@ -3859,11 +3926,11 @@ function markForEmitAsSingleLine(node) {
   ts17.forEachChild(node, markForEmitAsSingleLine);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
 import { ConstantPool } from "@angular/compiler";
 import ts19 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/visitor.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/visitor.mjs
 import ts18 from "typescript";
 function visit(node, visitor, context) {
   return visitor._visit(node, context);
@@ -3924,7 +3991,7 @@ var Visitor = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
 var NO_DECORATORS = /* @__PURE__ */ new Set();
 var CLOSURE_FILE_OVERVIEW_REGEXP = /\s+@fileoverview\s+/i;
 function ivyTransformFactory(compilation, reflector, importRewriter, defaultImportTracker, perf, isCore, isClosureCompilerEnabled) {
@@ -4112,10 +4179,10 @@ function nodeArrayFromDecoratorsArray(decorators) {
   return array;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/handler.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/handler.mjs
 import { compileClassMetadata, compileDeclareClassMetadata, compileDeclareDirectiveFromMetadata, compileDirectiveFromMetadata, FactoryTarget, makeBindingParser, WrappedNodeExpr as WrappedNodeExpr5 } from "@angular/compiler";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.mjs
 import { createMayBeForwardRefExpression, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr4, getSafePropertyAccessString, parseHostBindings, verifyHostBindings, WrappedNodeExpr as WrappedNodeExpr4 } from "@angular/compiler";
 import ts20 from "typescript";
 var EMPTY_OBJECT = {};
@@ -4528,7 +4595,7 @@ function toHostDirectiveMetadata(hostDirective, context, refEmitter) {
   };
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/symbol.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/symbol.mjs
 var DirectiveSymbol = class extends SemanticSymbol {
   constructor(decl, selector, inputs, outputs, exportAs, typeCheckMeta, typeParameters) {
     super(decl);
@@ -4605,7 +4672,7 @@ function isBaseClassEqual(current, previous) {
   return isSymbolEqual(current, previous);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/handler.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/handler.mjs
 var FIELD_DECORATORS = [
   "Input",
   "Output",
@@ -4627,7 +4694,7 @@ var LIFECYCLE_HOOKS = /* @__PURE__ */ new Set([
   "ngAfterContentChecked"
 ]);
 var DirectiveDecoratorHandler = class {
-  constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, isCore, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures, perf) {
+  constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, refEmitter, isCore, strictCtorDeps, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures, perf) {
     this.reflector = reflector;
     this.evaluator = evaluator;
     this.metaRegistry = metaRegistry;
@@ -4636,6 +4703,7 @@ var DirectiveDecoratorHandler = class {
     this.injectableRegistry = injectableRegistry;
     this.refEmitter = refEmitter;
     this.isCore = isCore;
+    this.strictCtorDeps = strictCtorDeps;
     this.semanticDepGraphUpdater = semanticDepGraphUpdater;
     this.annotateForClosureCompiler = annotateForClosureCompiler;
     this.compileUndecoratedClassesWithAngularFeatures = compileUndecoratedClassesWithAngularFeatures;
@@ -4715,7 +4783,9 @@ var DirectiveDecoratorHandler = class {
       schemas: null,
       decorator: analysis.decorator
     });
-    this.injectableRegistry.registerInjectable(node);
+    this.injectableRegistry.registerInjectable(node, {
+      ctorDeps: analysis.meta.deps
+    });
   }
   resolve(node, analysis, symbol) {
     if (this.semanticDepGraphUpdater !== null && analysis.baseClass instanceof Reference) {
@@ -4726,7 +4796,7 @@ var DirectiveDecoratorHandler = class {
       const providerDiagnostics = getProviderDiagnostics(analysis.providersRequiringFactory, analysis.meta.providers.node, this.injectableRegistry);
       diagnostics.push(...providerDiagnostics);
     }
-    const directiveDiagnostics = getDirectiveDiagnostics(node, this.metaReader, this.evaluator, this.reflector, this.scopeRegistry, "Directive");
+    const directiveDiagnostics = getDirectiveDiagnostics(node, this.injectableRegistry, this.evaluator, this.reflector, this.scopeRegistry, this.strictCtorDeps, "Directive");
     if (directiveDiagnostics !== null) {
       diagnostics.push(...directiveDiagnostics);
     }
@@ -4761,11 +4831,11 @@ var DirectiveDecoratorHandler = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.mjs
 import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, ExternalExpr as ExternalExpr5, FactoryTarget as FactoryTarget2, FunctionExpr as FunctionExpr2, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr2, R3Identifiers, R3SelectorScopeMode, ReturnStatement as ReturnStatement2, WrappedNodeExpr as WrappedNodeExpr6 } from "@angular/compiler";
 import ts22 from "typescript";
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/module_with_providers.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/module_with_providers.mjs
 import ts21 from "typescript";
 function createModuleWithProvidersResolver(reflector, isCore) {
   function _reflectModuleFromTypeParam(type, node) {
@@ -4832,7 +4902,7 @@ function isResolvedModuleWithProviders(sv) {
   return typeof sv.value === "object" && sv.value != null && sv.value.hasOwnProperty("ngModule") && sv.value.hasOwnProperty("mwpCall");
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.mjs
 var NgModuleSymbol = class extends SemanticSymbol {
   constructor() {
     super(...arguments);
@@ -5116,7 +5186,9 @@ var NgModuleDecoratorHandler = class {
         name: analysis.factorySymbolName
       });
     }
-    this.injectableRegistry.registerInjectable(node);
+    this.injectableRegistry.registerInjectable(node, {
+      ctorDeps: analysis.fac.deps
+    });
   }
   resolve(node, analysis) {
     const scope = this.scopeRegistry.getScopeOfModule(node);
@@ -5334,7 +5406,7 @@ function isSyntheticReference(ref) {
   return ref.synthetic;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/diagnostics.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/diagnostics.mjs
 function makeCyclicImportInfo(ref, type, cycle) {
   const name = ref.debugName || "(unknown)";
   const path = cycle.getPath().map((sf) => sf.fileName).join(" -> ");
@@ -5357,7 +5429,7 @@ function checkCustomElementSelectorForErrors(selector) {
   return null;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/resources.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/resources.mjs
 import { DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig, ParseSourceFile as ParseSourceFile2, parseTemplate } from "@angular/compiler";
 import ts23 from "typescript";
 function getTemplateDeclarationNodeForError(declaration) {
@@ -5663,7 +5735,7 @@ function _extractTemplateStyleUrls(template) {
   return template.styleUrls.map((url) => ({ url, source: 1, nodeForError }));
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/symbol.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/symbol.mjs
 var ComponentSymbol = class extends DirectiveSymbol {
   constructor() {
     super(...arguments);
@@ -5698,7 +5770,7 @@ var ComponentSymbol = class extends DirectiveSymbol {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/util.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/util.mjs
 function collectAnimationNames(value, animationTriggerNames) {
   if (value instanceof Map) {
     const name = value.get("name");
@@ -5734,7 +5806,7 @@ var animationTriggerResolver = (fn, node, resolve, unresolvable) => {
 function validateAndFlattenComponentImports(imports, expr) {
   const flattened = [];
   if (!Array.isArray(imports)) {
-    const error = createValueHasWrongTypeError(expr, imports, `'imports' must be an array of components, directives, pipes, or NgModules`).toDiagnostic();
+    const error = createValueHasWrongTypeError(expr, imports, `'imports' must be an array of components, directives, pipes, or NgModules.`).toDiagnostic();
     return {
       imports: [],
       diagnostics: [error]
@@ -5750,7 +5822,7 @@ function validateAndFlattenComponentImports(imports, expr) {
       if (isNamedClassDeclaration(ref.node)) {
         flattened.push(ref);
       } else {
-        diagnostics.push(createValueHasWrongTypeError(ref.getOriginForDiagnostics(expr), ref, `'imports' must be an array of components, directives, pipes, or NgModules`).toDiagnostic());
+        diagnostics.push(createValueHasWrongTypeError(ref.getOriginForDiagnostics(expr), ref, `'imports' must be an array of components, directives, pipes, or NgModules.`).toDiagnostic());
       }
     } else if (isLikelyModuleWithProviders(ref)) {
       let origin = expr;
@@ -5759,7 +5831,7 @@ function validateAndFlattenComponentImports(imports, expr) {
       }
       diagnostics.push(makeDiagnostic(ErrorCode.COMPONENT_UNKNOWN_IMPORT, origin, `'imports' contains a ModuleWithProviders value, likely the result of a 'Module.forRoot()'-style call. These calls are not used to configure components and are not valid in standalone component imports - consider importing them in the application bootstrap instead.`));
     } else {
-      diagnostics.push(createValueHasWrongTypeError(expr, imports, `'imports' must be an array of components, directives, pipes, or NgModules`).toDiagnostic());
+      diagnostics.push(createValueHasWrongTypeError(expr, imports, `'imports' must be an array of components, directives, pipes, or NgModules.`).toDiagnostic());
     }
   }
   return { imports: flattened, diagnostics };
@@ -5774,10 +5846,10 @@ function isLikelyModuleWithProviders(value) {
   return false;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
 var EMPTY_ARRAY2 = [];
 var ComponentDecoratorHandler = class {
-  constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, dtsScopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf, hostDirectivesResolver) {
+  constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, dtsScopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf, hostDirectivesResolver) {
     this.reflector = reflector;
     this.evaluator = evaluator;
     this.metaRegistry = metaRegistry;
@@ -5788,6 +5860,7 @@ var ComponentDecoratorHandler = class {
     this.typeCheckScopeRegistry = typeCheckScopeRegistry;
     this.resourceRegistry = resourceRegistry;
     this.isCore = isCore;
+    this.strictCtorDeps = strictCtorDeps;
     this.resourceLoader = resourceLoader;
     this.rootDirs = rootDirs;
     this.defaultPreserveWhitespaces = defaultPreserveWhitespaces;
@@ -6097,7 +6170,9 @@ var ComponentDecoratorHandler = class {
       decorator: analysis.decorator
     });
     this.resourceRegistry.registerResources(analysis.resources, node);
-    this.injectableRegistry.registerInjectable(node);
+    this.injectableRegistry.registerInjectable(node, {
+      ctorDeps: analysis.meta.deps
+    });
   }
   index(context, node, analysis) {
     if (analysis.isPoisoned && !this.usePoisonedData) {
@@ -6304,7 +6379,7 @@ var ComponentDecoratorHandler = class {
       const viewProviderDiagnostics = getProviderDiagnostics(analysis.viewProvidersRequiringFactory, analysis.meta.viewProviders.node, this.injectableRegistry);
       diagnostics.push(...viewProviderDiagnostics);
     }
-    const directiveDiagnostics = getDirectiveDiagnostics(node, this.metaReader, this.evaluator, this.reflector, this.scopeRegistry, "Component");
+    const directiveDiagnostics = getDirectiveDiagnostics(node, this.injectableRegistry, this.evaluator, this.reflector, this.scopeRegistry, this.strictCtorDeps, "Component");
     if (directiveDiagnostics !== null) {
       diagnostics.push(...directiveDiagnostics);
     }
@@ -6415,12 +6490,13 @@ function validateStandaloneImports(importRefs, importExpr, metaReader, scopeRead
   return diagnostics;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/injectable.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/injectable.mjs
 import { compileClassMetadata as compileClassMetadata4, compileDeclareClassMetadata as compileDeclareClassMetadata4, compileDeclareInjectableFromMetadata, compileInjectable, createMayBeForwardRefExpression as createMayBeForwardRefExpression2, FactoryTarget as FactoryTarget4, LiteralExpr as LiteralExpr3, WrappedNodeExpr as WrappedNodeExpr8 } from "@angular/compiler";
 import ts25 from "typescript";
 var InjectableDecoratorHandler = class {
-  constructor(reflector, isCore, strictCtorDeps, injectableRegistry, perf, errorOnDuplicateProv = true) {
+  constructor(reflector, evaluator, isCore, strictCtorDeps, injectableRegistry, perf, errorOnDuplicateProv = true) {
     this.reflector = reflector;
+    this.evaluator = evaluator;
     this.isCore = isCore;
     this.strictCtorDeps = strictCtorDeps;
     this.injectableRegistry = injectableRegistry;
@@ -6460,8 +6536,21 @@ var InjectableDecoratorHandler = class {
   symbol() {
     return null;
   }
-  register(node) {
-    this.injectableRegistry.registerInjectable(node);
+  register(node, analysis) {
+    this.injectableRegistry.registerInjectable(node, {
+      ctorDeps: analysis.ctorDeps
+    });
+  }
+  resolve(node, analysis, symbol) {
+    if (requiresValidCtor(analysis.meta)) {
+      const diagnostic = checkInheritanceOfInjectable(node, this.injectableRegistry, this.reflector, this.evaluator, this.strictCtorDeps, "Injectable");
+      if (diagnostic !== null) {
+        return {
+          diagnostics: [diagnostic]
+        };
+      }
+    }
+    return {};
   }
   compileFull(node, analysis) {
     return this.compile(compileNgFactoryDefField, (meta) => compileInjectable(meta, false), compileClassMetadata4, node, analysis);
@@ -6548,7 +6637,7 @@ function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, st
   }
   let ctorDeps = null;
   if (decorator.args.length === 0) {
-    if (strictCtorDeps) {
+    if (strictCtorDeps && !isAbstractClassDeclaration(clazz)) {
       ctorDeps = getValidConstructorDependencies(clazz, reflector, isCore);
     } else {
       ctorDeps = unwrapConstructorDependencies(getConstructorDependencies(clazz, reflector, isCore));
@@ -6556,7 +6645,7 @@ function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, st
     return ctorDeps;
   } else if (decorator.args.length === 1) {
     const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
-    if (strictCtorDeps && meta.useValue === void 0 && meta.useExisting === void 0 && meta.useClass === void 0 && meta.useFactory === void 0) {
+    if (strictCtorDeps && !isAbstractClassDeclaration(clazz) && requiresValidCtor(meta)) {
       ctorDeps = validateConstructorDependencies(clazz, rawCtorDeps);
     } else {
       ctorDeps = unwrapConstructorDependencies(rawCtorDeps);
@@ -6564,6 +6653,9 @@ function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, st
   }
   return ctorDeps;
 }
+function requiresValidCtor(meta) {
+  return meta.useValue === void 0 && meta.useExisting === void 0 && meta.useClass === void 0 && meta.useFactory === void 0;
+}
 function getDep(dep, reflector) {
   const meta = {
     token: new WrappedNodeExpr8(dep),
@@ -6615,7 +6707,7 @@ function getDep(dep, reflector) {
   return meta;
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/pipe.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/pipe.mjs
 import { compileClassMetadata as compileClassMetadata5, compileDeclareClassMetadata as compileDeclareClassMetadata5, compileDeclarePipeFromMetadata, compilePipeFromMetadata, FactoryTarget as FactoryTarget5, WrappedNodeExpr as WrappedNodeExpr9 } from "@angular/compiler";
 import ts26 from "typescript";
 var PipeSymbol = class extends SemanticSymbol {
@@ -6734,7 +6826,9 @@ var PipeDecoratorHandler = class {
       isStandalone: analysis.meta.isStandalone,
       decorator: analysis.decorator
     });
-    this.injectableRegistry.registerInjectable(node);
+    this.injectableRegistry.registerInjectable(node, {
+      ctorDeps: analysis.meta.deps
+    });
   }
   resolve(node) {
     const duplicateDeclData = this.scopeRegistry.getDuplicateDeclarations(node);
@@ -6762,19 +6856,19 @@ var PipeDecoratorHandler = class {
 export {
   forwardRefResolver,
   readBaseClass,
-  DynamicValue,
-  StaticInterpreter,
-  PartialEvaluator,
-  NoopReferencesRegistry,
-  SemanticDepGraphUpdater,
   MetaKind,
   CompoundMetadataReader,
   DtsMetadataReader,
   LocalMetadataRegistry,
   CompoundMetadataRegistry,
-  InjectableClassRegistry,
   ResourceRegistry,
   HostDirectivesResolver,
+  DynamicValue,
+  StaticInterpreter,
+  PartialEvaluator,
+  InjectableClassRegistry,
+  NoopReferencesRegistry,
+  SemanticDepGraphUpdater,
   ComponentScopeKind,
   CompoundComponentScopeReader,
   MetadataDtsModuleScopeResolver,
@@ -6808,4 +6902,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-VSAO3EZ7.js.map
+//# sourceMappingURL=chunk-KIQI22GZ.js.map