@angular/compiler-cli 15.0.0-next.5 → 15.0.0-next.6

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

@@ -13,7 +13,7 @@ import {
   reflectObjectLiteral,
   reflectTypeEntityToDeclaration,
   typeNodeToValueExpr
-} from "./chunk-XDX5RDY5.js";
+} from "./chunk-ZXBCBXWY.js";
 import {
   ErrorCode,
   FatalDiagnosticError,
@@ -33,7 +33,7 @@ import {
   translateExpression,
   translateStatement,
   translateType
-} from "./chunk-TF2TR2WS.js";
+} from "./chunk-EQ7NIVSK.js";
 import {
   combineModifiers,
   createPropertyDeclaration,
@@ -46,7 +46,7 @@ import {
   updateParameterDeclaration,
   updatePropertyDeclaration,
   updateSetAccessorDeclaration
-} from "./chunk-7YHMCUJT.js";
+} from "./chunk-F526PAOI.js";
 import {
   absoluteFrom,
   absoluteFromSourceFile,
@@ -292,6 +292,9 @@ 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
 var DynamicValue = class {
@@ -1494,7 +1497,8 @@ function createValueHasWrongTypeError(node, value, messageText) {
 function getProviderDiagnostics(providerClasses, providersDeclaration, registry) {
   const diagnostics = [];
   for (const provider of providerClasses) {
-    if (registry.isInjectable(provider.node)) {
+    const injectableMeta = registry.getInjectableMeta(provider.node);
+    if (injectableMeta !== null) {
       continue;
     }
     const contextNode = provider.getOriginForDiagnostics(providersDeclaration);
@@ -1505,7 +1509,7 @@ Either add the @Injectable() decorator to '${provider.node.name.text}', or confi
   }
   return diagnostics;
 }
-function getDirectiveDiagnostics(node, reader, evaluator, reflector, scopeRegistry, kind) {
+function getDirectiveDiagnostics(node, injectableRegistry, evaluator, reflector, scopeRegistry, strictInjectionParameters, kind) {
   let diagnostics = [];
   const addDiagnostics = (more) => {
     if (more === null) {
@@ -1522,7 +1526,7 @@ function getDirectiveDiagnostics(node, reader, evaluator, reflector, scopeRegist
   if (duplicateDeclarations !== null) {
     addDiagnostics(makeDuplicateDeclarationError(node, duplicateDeclarations, kind));
   }
-  addDiagnostics(checkInheritanceOfDirective(node, reader, reflector, evaluator));
+  addDiagnostics(checkInheritanceOfInjectable(node, injectableRegistry, reflector, evaluator, strictInjectionParameters, kind));
   return diagnostics;
 }
 function validateHostDirectives(origin, hostDirectives, metaReader) {
@@ -1545,7 +1549,20 @@ function validateHostDirectives(origin, hostDirectives, metaReader) {
 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) {
+function checkInheritanceOfInjectable(node, injectableRegistry, reflector, evaluator, strictInjectionParameters, kind) {
+  const classWithCtor = findInheritedCtor(node, injectableRegistry, reflector, evaluator);
+  if (classWithCtor === null || classWithCtor.isCtorValid) {
+    return null;
+  }
+  if (!classWithCtor.isDecorated) {
+    return getInheritedUndecoratedCtorDiagnostic(node, classWithCtor.ref, kind);
+  }
+  if (!strictInjectionParameters || isAbstractClassDeclaration(node)) {
+    return null;
+  }
+  return getInheritedInvalidCtorDiagnostic(node, classWithCtor.ref, kind);
+}
+function findInheritedCtor(node, injectableRegistry, reflector, evaluator) {
   if (!reflector.isClass(node) || reflector.getConstructorParameters(node) !== null) {
     return null;
   }
@@ -1554,26 +1571,37 @@ function checkInheritanceOfDirective(node, reader, reflector, evaluator) {
     if (baseClass === "dynamic") {
       return null;
     }
-    const baseClassMeta = reader.getDirectiveMetadata(baseClass);
-    if (baseClassMeta !== null) {
-      return null;
-    }
-    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;
+    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
+        };
+      }
     }
-    baseClass = newParentClass;
+    baseClass = readBaseClass(baseClass.node, reflector, evaluator);
   }
   return null;
 }
-function getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader) {
-  const subclassMeta = reader.getDirectiveMetadata(new Reference(node));
-  const dirOrComp = subclassMeta.isComponent ? "Component" : "Directive";
+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;
-  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}.`);
+  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/annotations/common/src/evaluation.mjs
@@ -1620,1013 +1648,1027 @@ function compileDeclareFactory(metadata) {
   return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
 }
 
-// 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)) {
-    return null;
-  }
-  const id = reflection.getAdjacentNameOfClass(clazz);
-  const classDecorators = reflection.getDecoratorsOfDeclaration(clazz);
-  if (classDecorators === null) {
-    return null;
+// 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 ts8 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);
   }
-  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;
+  static empty() {
+    return new ClassPropertyMapping(/* @__PURE__ */ new Map());
   }
-  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))
-    ]);
+  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);
   }
-  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(", "));
+  static merge(a, b) {
+    const forwardMap = new Map(a.forwardMap.entries());
+    for (const [classPropertyName, inputOrOutput] of b.forwardMap) {
+      forwardMap.set(classPropertyName, inputOrOutput);
+    }
+    return new ClassPropertyMapping(forwardMap);
   }
-  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(ts7.factory.createObjectLiteralExpression(decoratedMembers));
+  get classPropertyNames() {
+    return Array.from(this.forwardMap.keys());
   }
-  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(ts7.factory.createArrayLiteralExpression(ngDecorators));
-    mapEntries.push({ key: "decorators", value, quoted: false });
+  get propertyNames() {
+    return Array.from(this.reverseMap.keys());
   }
-  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);
-}
-function decoratorToMetadata(decorator, wrapFunctionsInParens) {
-  if (decorator.identifier === null) {
-    throw new Error("Illegal state: synthesized decorator cannot be emitted in class metadata.");
+  hasBindingPropertyName(propertyName) {
+    return this.reverseMap.has(propertyName);
   }
-  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)));
+  getByBindingPropertyName(propertyName) {
+    return this.reverseMap.has(propertyName) ? this.reverseMap.get(propertyName) : null;
   }
-  return ts7.factory.createObjectLiteralExpression(properties, true);
-}
-function isAngularDecorator2(decorator, isCore) {
-  return isCore || decorator.import !== null && decorator.import.from === "@angular/core";
-}
-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];
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/references_registry.mjs
-var NoopReferencesRegistry = class {
-  add(source, ...references) {
+  getByClassPropertyName(classPropertyName) {
+    return this.forwardMap.has(classPropertyName) ? this.forwardMap.get(classPropertyName) : null;
   }
-};
-
-// 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`);
+  toDirectMappedObject() {
+    const obj = {};
+    for (const [classPropertyName, inputOrOutput] of this.forwardMap) {
+      obj[classPropertyName] = inputOrOutput.bindingPropertyName;
+    }
+    return obj;
   }
-  for (const schemaRef of result) {
-    if (!(schemaRef instanceof Reference)) {
-      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
+  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 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`);
+    return obj;
+  }
+  *[Symbol.iterator]() {
+    for (const [classPropertyName, inputOrOutput] of this.forwardMap.entries()) {
+      yield [classPropertyName, inputOrOutput.bindingPropertyName];
     }
-    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`);
+  }
+};
+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 schemas;
+  return reverseMap;
 }
 
-// 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)) {
-    return null;
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/util.mjs
+import ts7 from "typescript";
+function extractReferencesFromType(checker, def, bestGuessOwningModule) {
+  if (!ts7.isTupleTypeNode(def)) {
+    return [];
   }
-  return decl.name.text;
+  return def.elements.map((element) => {
+    if (!ts7.isTypeQueryNode(element)) {
+      throw new Error(`Expected TypeQueryNode: ${nodeDebugInfo(element)}`);
+    }
+    return extraReferenceFromTypeQuery(checker, element, def, bestGuessOwningModule);
+  });
 }
-
-// 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;
+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)}`);
   }
-  isTypeCheckApiAffected() {
-    return false;
+  if (from !== null && !from.startsWith(".")) {
+    return new Reference(node, { specifier: from, resolutionContext: origin.getSourceFile().fileName });
   }
-};
-var SemanticDepGraph = class {
-  constructor() {
-    this.files = /* @__PURE__ */ new Map();
-    this.symbolByDecl = /* @__PURE__ */ new Map();
+  return new Reference(node, bestGuessOwningModule);
+}
+function readBooleanType(type) {
+  if (!ts7.isLiteralTypeNode(type)) {
+    return null;
   }
-  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);
-    }
+  switch (type.literal.kind) {
+    case ts7.SyntaxKind.TrueKeyword:
+      return true;
+    case ts7.SyntaxKind.FalseKeyword:
+      return false;
+    default:
+      return null;
   }
-  getEquivalentSymbol(symbol) {
-    let previousSymbol = this.getSymbolByDecl(symbol.decl);
-    if (previousSymbol === null && symbol.identifier !== null) {
-      previousSymbol = this.getSymbolByName(symbol.path, symbol.identifier);
-    }
-    return previousSymbol;
+}
+function readStringType(type) {
+  if (!ts7.isLiteralTypeNode(type) || !ts7.isStringLiteral(type.literal)) {
+    return null;
   }
-  getSymbolByName(path, identifier) {
-    if (!this.files.has(path)) {
-      return null;
-    }
-    const file = this.files.get(path);
-    if (!file.has(identifier)) {
-      return null;
-    }
-    return file.get(identifier);
+  return type.literal.text;
+}
+function readMapType(type, valueTransform) {
+  if (!ts7.isTypeLiteralNode(type)) {
+    return {};
   }
-  getSymbolByDecl(decl) {
-    if (!this.symbolByDecl.has(decl)) {
-      return null;
+  const obj = {};
+  type.members.forEach((member) => {
+    if (!ts7.isPropertySignature(member) || member.type === void 0 || member.name === void 0 || !ts7.isStringLiteral(member.name) && !ts7.isIdentifier(member.name)) {
+      return;
     }
-    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 value = valueTransform(member.type);
+    if (value === null) {
+      return null;
     }
-    const needsEmit = this.determineInvalidatedFiles(this.priorGraph);
-    const needsTypeCheckEmit = this.determineInvalidatedTypeCheckFiles(this.priorGraph);
-    return {
-      needsEmit,
-      needsTypeCheckEmit,
-      newGraph: this.newGraph
-    };
+    obj[member.name.text] = value;
+  });
+  return obj;
+}
+function readStringArrayType(type) {
+  if (!ts7.isTupleTypeNode(type)) {
+    return [];
   }
-  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 res = [];
+  type.elements.forEach((el) => {
+    if (!ts7.isLiteralTypeNode(el) || !ts7.isStringLiteral(el.literal)) {
+      return;
     }
-    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);
-      }
+    res.push(el.literal.text);
+  });
+  return res;
+}
+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;
     }
-    return needsEmit;
-  }
-  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 (isRestricted(field.node)) {
+      restrictedInputFields.add(classPropertyName);
     }
-    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);
-      }
+    if (field.nameNode !== null && ts7.isStringLiteral(field.nameNode)) {
+      stringLiteralInputFields.add(classPropertyName);
     }
-    return needsTypeCheckEmit;
   }
-  getSemanticReference(decl, expr) {
-    return {
-      symbol: this.getSymbol(decl),
-      importPath: getImportPath(expr)
-    };
+  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 === ts7.SyntaxKind.PrivateKeyword || kind === ts7.SyntaxKind.ProtectedKeyword || kind === ts7.SyntaxKind.ReadonlyKeyword;
+  });
+}
+function extractTemplateGuard(member) {
+  if (!member.name.startsWith("ngTemplateGuard_")) {
+    return null;
   }
-  getSymbol(decl) {
-    const symbol = this.newGraph.getSymbolByDecl(decl);
-    if (symbol === null) {
-      return this.getOpaqueSymbol(decl);
+  const inputName = afterUnderscore(member.name);
+  if (member.kind === ClassMemberKind.Property) {
+    let type = null;
+    if (member.type !== null && ts7.isLiteralTypeNode(member.type) && ts7.isStringLiteral(member.type.literal)) {
+      type = member.type.literal.text;
     }
-    return symbol;
-  }
-  getOpaqueSymbol(decl) {
-    if (this.opaqueSymbols.has(decl)) {
-      return this.opaqueSymbols.get(decl);
+    if (type !== "binding") {
+      return null;
     }
-    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}`;
+    return { inputName, type };
+  } else if (member.kind === ClassMemberKind.Method) {
+    return { inputName, type: "invocation" };
   } 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;
-  }
-  return a.path === b.path && a.identifier === b.identifier;
-}
-function isReferenceEqual(a, b) {
-  if (!isSymbolEqual(a.symbol, b.symbol)) {
-    return false;
-  }
-  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;
+function extractCoercedInput(member) {
+  if (member.kind !== ClassMemberKind.Property || !member.name.startsWith("ngAcceptInputType_")) {
+    return null;
   }
-  return !a.some((item, index) => !equalityTester(item, b[index]));
+  return afterUnderscore(member.name);
 }
-function isSetEqual(a, b, equalityTester = referenceEquality) {
-  if (a === null || b === null) {
-    return a === b;
-  }
-  if (a.size !== b.size) {
-    return false;
+var CompoundMetadataReader = class {
+  constructor(readers) {
+    this.readers = readers;
   }
-  for (const itemA of a) {
-    let found = false;
-    for (const itemB of b) {
-      if (equalityTester(itemA, itemB)) {
-        found = true;
-        break;
+  getDirectiveMetadata(node) {
+    for (const reader of this.readers) {
+      const meta = reader.getDirectiveMetadata(node);
+      if (meta !== null) {
+        return meta;
       }
     }
-    if (!found) {
-      return false;
+    return null;
+  }
+  getNgModuleMetadata(node) {
+    for (const reader of this.readers) {
+      const meta = reader.getNgModuleMetadata(node);
+      if (meta !== null) {
+        return meta;
+      }
     }
+    return null;
   }
-  return true;
-}
-
-// 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) {
+  getPipeMetadata(node) {
+    for (const reader of this.readers) {
+      const meta = reader.getPipeMetadata(node);
+      if (meta !== null) {
+        return meta;
+      }
+    }
     return null;
   }
-  return node.typeParameters.map((typeParam) => ({ hasGenericTypeBound: typeParam.constraint !== void 0 }));
-}
-function areTypeParametersEqual(current, previous) {
-  if (!isArrayEqual(current, previous, isTypeParameterEqual)) {
-    return false;
+};
+function afterUnderscore(str) {
+  const pos = str.indexOf("_");
+  if (pos === -1) {
+    throw new Error(`Expected '${str}' to contain '_'`);
   }
-  if (current !== null && current.some((typeParam) => typeParam.hasGenericTypeBound)) {
-    return false;
-  }
-  return true;
+  return str.slice(pos + 1);
 }
-function isTypeParameterEqual(a, b) {
-  return a.hasGenericTypeBound === b.hasGenericTypeBound;
+function hasInjectableFields(clazz, host) {
+  const members = host.getMembersOfClass(clazz);
+  return members.some(({ isStatic, name }) => isStatic && (name === "\u0275prov" || name === "\u0275fac"));
 }
 
-// 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);
+var DtsMetadataReader = class {
+  constructor(checker, reflector) {
+    this.checker = checker;
+    this.reflector = reflector;
   }
-  static empty() {
-    return new ClassPropertyMapping(/* @__PURE__ */ new Map());
+  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 || !ts8.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
+    };
   }
-  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);
+  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 || !ts8.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
+      return null;
     }
-    return new ClassPropertyMapping(forwardMap);
+    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
+    };
   }
-  static merge(a, b) {
-    const forwardMap = new Map(a.forwardMap.entries());
-    for (const [classPropertyName, inputOrOutput] of b.forwardMap) {
-      forwardMap.set(classPropertyName, inputOrOutput);
+  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 || !ts8.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
+      return null;
     }
-    return new ClassPropertyMapping(forwardMap);
+    const type = def.type.typeArguments[1];
+    if (!ts8.isLiteralTypeNode(type) || !ts8.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
+    };
   }
-  get classPropertyNames() {
-    return Array.from(this.forwardMap.keys());
+};
+function readBaseClass2(clazz, checker, reflector) {
+  if (!isNamedClassDeclaration(clazz)) {
+    return reflector.hasBaseClass(clazz) ? "dynamic" : null;
   }
-  get propertyNames() {
-    return Array.from(this.reverseMap.keys());
+  if (clazz.heritageClauses !== void 0) {
+    for (const clause of clazz.heritageClauses) {
+      if (clause.token === ts8.SyntaxKind.ExtendsKeyword) {
+        const baseExpr = clause.types[0].expression;
+        let symbol = checker.getSymbolAtLocation(baseExpr);
+        if (symbol === void 0) {
+          return "dynamic";
+        } else if (symbol.flags & ts8.SymbolFlags.Alias) {
+          symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (symbol.valueDeclaration !== void 0 && isNamedClassDeclaration(symbol.valueDeclaration)) {
+          return new Reference(symbol.valueDeclaration);
+        } else {
+          return "dynamic";
+        }
+      }
+    }
   }
-  hasBindingPropertyName(propertyName) {
-    return this.reverseMap.has(propertyName);
+  return null;
+}
+function readHostDirectivesType(checker, type, bestGuessOwningModule) {
+  if (!ts8.isTupleTypeNode(type) || type.elements.length === 0) {
+    return null;
   }
-  getByBindingPropertyName(propertyName) {
-    return this.reverseMap.has(propertyName) ? this.reverseMap.get(propertyName) : null;
+  const result = [];
+  for (const hostDirectiveType of type.elements) {
+    const { directive, inputs, outputs } = readMapType(hostDirectiveType, (type2) => type2);
+    if (directive) {
+      if (!ts8.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)
+      });
+    }
   }
-  getByClassPropertyName(classPropertyName) {
-    return this.forwardMap.has(classPropertyName) ? this.forwardMap.get(classPropertyName) : null;
+  return result.length > 0 ? result : null;
+}
+
+// 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}`);
   }
-  toDirectMappedObject() {
-    const obj = {};
-    for (const [classPropertyName, inputOrOutput] of this.forwardMap) {
-      obj[classPropertyName] = inputOrOutput.bindingPropertyName;
-    }
-    return obj;
+  if (topMeta.baseClass === null) {
+    return topMeta;
   }
-  toJointMappedObject() {
-    const obj = {};
-    for (const [classPropertyName, inputOrOutput] of this.forwardMap) {
-      if (inputOrOutput.bindingPropertyName === classPropertyName) {
-        obj[classPropertyName] = inputOrOutput.bindingPropertyName;
+  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 {
-        obj[classPropertyName] = [inputOrOutput.bindingPropertyName, classPropertyName];
+        isDynamic = true;
       }
     }
-    return obj;
-  }
-  *[Symbol.iterator]() {
-    for (const [classPropertyName, inputOrOutput] of this.forwardMap.entries()) {
-      yield [classPropertyName, inputOrOutput.bindingPropertyName];
+    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);
     }
-  }
-};
-function reverseMapFromForwardMap(forwardMap) {
-  const reverseMap = /* @__PURE__ */ new Map();
-  for (const [_, inputOrOutput] of forwardMap) {
-    if (!reverseMap.has(inputOrOutput.bindingPropertyName)) {
-      reverseMap.set(inputOrOutput.bindingPropertyName, []);
+    for (const undeclaredInputField of meta.undeclaredInputFields) {
+      undeclaredInputFields.add(undeclaredInputField);
     }
-    reverseMap.get(inputOrOutput.bindingPropertyName).push(inputOrOutput);
-  }
-  return reverseMap;
+    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/metadata/src/util.mjs
-import ts10 from "typescript";
-function extractReferencesFromType(checker, def, bestGuessOwningModule) {
-  if (!ts10.isTupleTypeNode(def)) {
-    return [];
+// 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();
   }
-  return def.elements.map((element) => {
-    if (!ts10.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)}`);
+  getDirectiveMetadata(ref) {
+    return this.directives.has(ref.node) ? this.directives.get(ref.node) : null;
   }
-  if (from !== null && !from.startsWith(".")) {
-    return new Reference(node, { specifier: from, resolutionContext: origin.getSourceFile().fileName });
+  getNgModuleMetadata(ref) {
+    return this.ngModules.has(ref.node) ? this.ngModules.get(ref.node) : null;
   }
-  return new Reference(node, bestGuessOwningModule);
-}
-function readBooleanType(type) {
-  if (!ts10.isLiteralTypeNode(type)) {
-    return null;
+  getPipeMetadata(ref) {
+    return this.pipes.has(ref.node) ? this.pipes.get(ref.node) : null;
   }
-  switch (type.literal.kind) {
-    case ts10.SyntaxKind.TrueKeyword:
-      return true;
-    case ts10.SyntaxKind.FalseKeyword:
-      return false;
-    default:
-      return null;
+  registerDirectiveMetadata(meta) {
+    this.directives.set(meta.ref.node, meta);
   }
-}
-function readStringType(type) {
-  if (!ts10.isLiteralTypeNode(type) || !ts10.isStringLiteral(type.literal)) {
-    return null;
+  registerNgModuleMetadata(meta) {
+    this.ngModules.set(meta.ref.node, meta);
   }
-  return type.literal.text;
-}
-function readMapType(type, valueTransform) {
-  if (!ts10.isTypeLiteralNode(type)) {
-    return {};
+  registerPipeMetadata(meta) {
+    this.pipes.set(meta.ref.node, meta);
   }
-  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;
-    }
-    obj[member.name.text] = value;
-  });
-  return obj;
-}
-function readStringArrayType(type) {
-  if (!ts10.isTupleTypeNode(type)) {
-    return [];
+  getKnownDirectives() {
+    return this.directives.keys();
   }
-  const res = [];
-  type.elements.forEach((el) => {
-    if (!ts10.isLiteralTypeNode(el) || !ts10.isStringLiteral(el.literal)) {
-      return;
-    }
-    res.push(el.literal.text);
-  });
-  return res;
-}
-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;
+};
+var CompoundMetadataRegistry = class {
+  constructor(registries) {
+    this.registries = registries;
+  }
+  registerDirectiveMetadata(meta) {
+    for (const registry of this.registries) {
+      registry.registerDirectiveMetadata(meta);
     }
-    if (isRestricted(field.node)) {
-      restrictedInputFields.add(classPropertyName);
+  }
+  registerNgModuleMetadata(meta) {
+    for (const registry of this.registries) {
+      registry.registerNgModuleMetadata(meta);
     }
-    if (field.nameNode !== null && ts10.isStringLiteral(field.nameNode)) {
-      stringLiteralInputFields.add(classPropertyName);
+  }
+  registerPipeMetadata(meta) {
+    for (const registry of this.registries) {
+      registry.registerPipeMetadata(meta);
     }
   }
-  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;
-  });
-}
-function extractTemplateGuard(member) {
-  if (!member.name.startsWith("ngTemplateGuard_")) {
-    return null;
+};
+
+// bazel-out/k8-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();
   }
-  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;
+  getComponentsWithTemplate(template) {
+    if (!this.externalTemplateToComponentsMap.has(template)) {
+      return /* @__PURE__ */ new Set();
     }
-    if (type !== "binding") {
-      return null;
+    return this.externalTemplateToComponentsMap.get(template);
+  }
+  registerResources(resources, component) {
+    if (resources.template !== null) {
+      this.registerTemplate(resources.template, component);
+    }
+    for (const style of resources.styles) {
+      this.registerStyle(style, component);
     }
-    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_")) {
-    return 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);
   }
-  return afterUnderscore(member.name);
-}
-var CompoundMetadataReader = class {
-  constructor(readers) {
-    this.readers = readers;
+  getTemplate(component) {
+    if (!this.componentToTemplateMap.has(component)) {
+      return null;
+    }
+    return this.componentToTemplateMap.get(component);
   }
-  getDirectiveMetadata(node) {
-    for (const reader of this.readers) {
-      const meta = reader.getDirectiveMetadata(node);
-      if (meta !== null) {
-        return meta;
+  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 null;
+    this.componentToStylesMap.get(component).add(styleResource);
   }
-  getNgModuleMetadata(node) {
-    for (const reader of this.readers) {
-      const meta = reader.getNgModuleMetadata(node);
-      if (meta !== null) {
-        return meta;
-      }
+  getStyles(component) {
+    if (!this.componentToStylesMap.has(component)) {
+      return /* @__PURE__ */ new Set();
     }
-    return null;
+    return this.componentToStylesMap.get(component);
   }
-  getPipeMetadata(node) {
-    for (const reader of this.readers) {
-      const meta = reader.getPipeMetadata(node);
-      if (meta !== null) {
-        return meta;
-      }
+  getComponentsWithStyle(styleUrl) {
+    if (!this.externalStyleToComponentsMap.has(styleUrl)) {
+      return /* @__PURE__ */ new Set();
     }
-    return null;
+    return this.externalStyleToComponentsMap.get(styleUrl);
   }
 };
-function afterUnderscore(str) {
-  const pos = str.indexOf("_");
-  if (pos === -1) {
-    throw new Error(`Expected '${str}' to contain '_'`);
-  }
-  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/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/dts.mjs
-var DtsMetadataReader = class {
-  constructor(checker, reflector) {
-    this.checker = checker;
-    this.reflector = reflector;
+// 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();
   }
-  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;
+  resolve(metadata) {
+    if (this.cache.has(metadata.ref.node)) {
+      return this.cache.get(metadata.ref.node);
     }
-    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
-    };
+    const results = metadata.hostDirectives && metadata.hostDirectives.length > 0 ? this.walkHostDirectives(metadata.hostDirectives, []) : EMPTY_ARRAY;
+    this.cache.set(metadata.ref.node, results);
+    return results;
   }
-  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;
+  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)
+      });
     }
-    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
-    };
+    return results;
   }
-  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;
+  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];
+            }
+          }
+        }
+      }
     }
-    const type = def.type.typeArguments[1];
-    if (!ts11.isLiteralTypeNode(type) || !ts11.isStringLiteral(type.literal)) {
+    return ClassPropertyMapping.fromMappedObject(result);
+  }
+};
+
+// bazel-out/k8-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();
+  }
+  registerInjectable(declaration, meta) {
+    this.classes.set(declaration, meta);
+  }
+  getInjectableMeta(declaration) {
+    if (this.classes.has(declaration)) {
+      return this.classes.get(declaration);
+    }
+    if (!hasInjectableFields(declaration, this.host)) {
       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
+    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/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;
+  }
+  const id = reflection.getAdjacentNameOfClass(clazz);
+  const classDecorators = reflection.getDecoratorsOfDeclaration(clazz);
+  if (classDecorators === null) {
+    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) {
+    return 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))
+    ]);
   }
-};
-function readBaseClass2(clazz, checker, reflector) {
-  if (!isNamedClassDeclaration(clazz)) {
-    return reflector.hasBaseClass(clazz) ? "dynamic" : null;
+  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(", "));
   }
-  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 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));
   }
-  return null;
+  return {
+    type: new WrappedNodeExpr3(id),
+    decorators: metaDecorators,
+    ctorParameters: metaCtorParameters,
+    propDecorators: metaPropDecorators
+  };
 }
-function readHostDirectivesType(checker, type, bestGuessOwningModule) {
-  if (!ts11.isTupleTypeNode(type) || type.elements.length === 0) {
-    return null;
+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 });
   }
-  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 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.");
   }
-  return result.length > 0 ? result : null;
+  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/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/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/references_registry.mjs
+var NoopReferencesRegistry = class {
+  add(source, ...references) {
   }
-  if (topMeta.baseClass === null) {
-    return topMeta;
+};
+
+// 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`);
   }
-  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 schemaRef of result) {
+    if (!(schemaRef instanceof Reference)) {
+      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
     }
-    for (const restrictedInputField of meta.restrictedInputFields) {
-      restrictedInputFields.add(restrictedInputField);
+    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`);
     }
-    for (const field of meta.stringLiteralInputFields) {
-      stringLiteralInputFields.add(field);
+    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`);
     }
-  };
-  addMetadata(topMeta);
-  return {
-    ...topMeta,
-    inputs,
-    outputs,
-    coercedInputFields,
-    undeclaredInputFields,
-    restrictedInputFields,
-    stringLiteralInputFields,
-    baseClass: isDynamic ? "dynamic" : null,
-    isStructural
-  };
+  }
+  return schemas;
 }
 
-// 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();
-  }
-  getDirectiveMetadata(ref) {
-    return this.directives.has(ref.node) ? this.directives.get(ref.node) : null;
-  }
-  getNgModuleMetadata(ref) {
-    return this.ngModules.has(ref.node) ? this.ngModules.get(ref.node) : null;
-  }
-  getPipeMetadata(ref) {
-    return this.pipes.has(ref.node) ? this.pipes.get(ref.node) : null;
-  }
-  registerDirectiveMetadata(meta) {
-    this.directives.set(meta.ref.node, meta);
+// 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 ts10 from "typescript";
+var SemanticSymbol = class {
+  constructor(decl) {
+    this.decl = decl;
+    this.path = absoluteFromSourceFile(decl.getSourceFile());
+    this.identifier = getSymbolIdentifier(decl);
   }
-  registerNgModuleMetadata(meta) {
-    this.ngModules.set(meta.ref.node, meta);
+};
+function getSymbolIdentifier(decl) {
+  if (!ts10.isSourceFile(decl.parent)) {
+    return null;
   }
-  registerPipeMetadata(meta) {
-    this.pipes.set(meta.ref.node, meta);
+  return decl.name.text;
+}
+
+// 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;
   }
-  getKnownDirectives() {
-    return this.directives.keys();
+  isTypeCheckApiAffected() {
+    return false;
   }
 };
-var CompoundMetadataRegistry = class {
-  constructor(registries) {
-    this.registries = registries;
+var SemanticDepGraph = class {
+  constructor() {
+    this.files = /* @__PURE__ */ new Map();
+    this.symbolByDecl = /* @__PURE__ */ new Map();
   }
-  registerDirectiveMetadata(meta) {
-    for (const registry of this.registries) {
-      registry.registerDirectiveMetadata(meta);
+  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);
     }
   }
-  registerNgModuleMetadata(meta) {
-    for (const registry of this.registries) {
-      registry.registerNgModuleMetadata(meta);
+  getEquivalentSymbol(symbol) {
+    let previousSymbol = this.getSymbolByDecl(symbol.decl);
+    if (previousSymbol === null && symbol.identifier !== null) {
+      previousSymbol = this.getSymbolByName(symbol.path, symbol.identifier);
     }
+    return previousSymbol;
   }
-  registerPipeMetadata(meta) {
-    for (const registry of this.registries) {
-      registry.registerPipeMetadata(meta);
+  getSymbolByName(path, identifier) {
+    if (!this.files.has(path)) {
+      return null;
     }
+    const file = this.files.get(path);
+    if (!file.has(identifier)) {
+      return null;
+    }
+    return file.get(identifier);
   }
-};
-var InjectableClassRegistry = class {
-  constructor(host) {
-    this.host = host;
-    this.classes = /* @__PURE__ */ new Set();
-  }
-  registerInjectable(declaration) {
-    this.classes.add(declaration);
-  }
-  isInjectable(declaration) {
-    return this.classes.has(declaration) || hasInjectableFields(declaration, this.host);
+  getSymbolByDecl(decl) {
+    if (!this.symbolByDecl.has(decl)) {
+      return null;
+    }
+    return this.symbolByDecl.get(decl);
   }
 };
-
-// bazel-out/k8-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();
+var SemanticDepGraphUpdater = class {
+  constructor(priorGraph) {
+    this.priorGraph = priorGraph;
+    this.newGraph = new SemanticDepGraph();
+    this.opaqueSymbols = /* @__PURE__ */ new Map();
   }
-  getComponentsWithTemplate(template) {
-    if (!this.externalTemplateToComponentsMap.has(template)) {
-      return /* @__PURE__ */ new Set();
-    }
-    return this.externalTemplateToComponentsMap.get(template);
+  registerSymbol(symbol) {
+    this.newGraph.registerSymbol(symbol);
   }
-  registerResources(resources, component) {
-    if (resources.template !== null) {
-      this.registerTemplate(resources.template, component);
-    }
-    for (const style of resources.styles) {
-      this.registerStyle(style, component);
+  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/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters.mjs
+import ts11 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;
   }
-  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/k8-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
 var ComponentScopeKind;
@@ -4627,7 +4669,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 +4678,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 +4758,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 +4771,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);
     }
@@ -5116,7 +5161,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);
@@ -5734,7 +5781,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 +5797,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 +5806,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 };
@@ -5777,7 +5824,7 @@ function isLikelyModuleWithProviders(value) {
 // bazel-out/k8-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 +5835,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 +6145,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 +6354,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);
     }
@@ -6419,8 +6469,9 @@ function validateStandaloneImports(importRefs, importExpr, metaReader, scopeRead
 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 +6511,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 +6612,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 +6620,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 +6628,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),
@@ -6734,7 +6801,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);
@@ -6765,16 +6834,16 @@ export {
   DynamicValue,
   StaticInterpreter,
   PartialEvaluator,
-  NoopReferencesRegistry,
-  SemanticDepGraphUpdater,
   MetaKind,
   CompoundMetadataReader,
   DtsMetadataReader,
   LocalMetadataRegistry,
   CompoundMetadataRegistry,
-  InjectableClassRegistry,
   ResourceRegistry,
   HostDirectivesResolver,
+  InjectableClassRegistry,
+  NoopReferencesRegistry,
+  SemanticDepGraphUpdater,
   ComponentScopeKind,
   CompoundComponentScopeReader,
   MetadataDtsModuleScopeResolver,
@@ -6808,4 +6877,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-R4GD76QD.js.map