@angular/compiler-cli 14.0.0-next.1 → 14.0.0-next.4

package/bundles/{chunk-C44PYKVA.js → chunk-26T3CJIJ.js}

@@ -13,7 +13,7 @@ import {
   reflectObjectLiteral,
   reflectTypeEntityToDeclaration,
   typeNodeToValueExpr
-} from "./chunk-7PY7XEFH.js";
+} from "./chunk-AR265E4B.js";
 import {
   ErrorCode,
   FatalDiagnosticError,
@@ -35,7 +35,7 @@ import {
   translateExpression,
   translateStatement,
   translateType
-} from "./chunk-XNYP2SFR.js";
+} from "./chunk-5RC6M6GX.js";
 import {
   absoluteFrom,
   absoluteFromSourceFile,
@@ -51,6 +51,228 @@ import {
   __spreadValues
 } from "./chunk-WQ3TNYTD.js";
 
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/util.mjs
+import { ExternalExpr, ParseLocation, ParseSourceFile, ParseSourceSpan, ReadPropExpr, WrappedNodeExpr } from "@angular/compiler";
+import ts from "typescript";
+function valueReferenceToExpression(valueRef) {
+  if (valueRef.kind === 2) {
+    return null;
+  } else if (valueRef.kind === 0) {
+    const expr = new WrappedNodeExpr(valueRef.expression);
+    if (valueRef.defaultImportStatement !== null) {
+      attachDefaultImportDeclaration(expr, valueRef.defaultImportStatement);
+    }
+    return expr;
+  } else {
+    let importExpr = new ExternalExpr({ moduleName: valueRef.moduleName, name: valueRef.importedName });
+    if (valueRef.nestedPath !== null) {
+      for (const property of valueRef.nestedPath) {
+        importExpr = new ReadPropExpr(importExpr, property);
+      }
+    }
+    return importExpr;
+  }
+}
+function toR3Reference(origin, valueRef, typeRef, valueContext, typeContext, refEmitter) {
+  const emittedValueRef = refEmitter.emit(valueRef, valueContext);
+  assertSuccessfulReferenceEmit(emittedValueRef, origin, "class");
+  const emittedTypeRef = refEmitter.emit(typeRef, typeContext, ImportFlags.ForceNewImport | ImportFlags.AllowTypeImports);
+  assertSuccessfulReferenceEmit(emittedTypeRef, origin, "class");
+  return {
+    value: emittedValueRef.expression,
+    type: emittedTypeRef.expression
+  };
+}
+function isAngularCore(decorator) {
+  return decorator.import !== null && decorator.import.from === "@angular/core";
+}
+function isAngularCoreReference(reference, symbolName) {
+  return reference.ownedByModuleGuess === "@angular/core" && reference.debugName === symbolName;
+}
+function findAngularDecorator(decorators, name, isCore) {
+  return decorators.find((decorator) => isAngularDecorator(decorator, name, isCore));
+}
+function isAngularDecorator(decorator, name, isCore) {
+  if (isCore) {
+    return decorator.name === name;
+  } else if (isAngularCore(decorator)) {
+    return decorator.import.name === name;
+  }
+  return false;
+}
+function unwrapExpression(node) {
+  while (ts.isAsExpression(node) || ts.isParenthesizedExpression(node)) {
+    node = node.expression;
+  }
+  return node;
+}
+function expandForwardRef(arg) {
+  arg = unwrapExpression(arg);
+  if (!ts.isArrowFunction(arg) && !ts.isFunctionExpression(arg)) {
+    return null;
+  }
+  const body = arg.body;
+  if (ts.isBlock(body)) {
+    if (body.statements.length !== 1) {
+      return null;
+    }
+    const stmt = body.statements[0];
+    if (!ts.isReturnStatement(stmt) || stmt.expression === void 0) {
+      return null;
+    }
+    return stmt.expression;
+  } else {
+    return body;
+  }
+}
+function tryUnwrapForwardRef(node, reflector) {
+  node = unwrapExpression(node);
+  if (!ts.isCallExpression(node) || node.arguments.length !== 1) {
+    return null;
+  }
+  const fn = ts.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression;
+  if (!ts.isIdentifier(fn)) {
+    return null;
+  }
+  const expr = expandForwardRef(node.arguments[0]);
+  if (expr === null) {
+    return null;
+  }
+  const imp = reflector.getImportOfIdentifier(fn);
+  if (imp === null || imp.from !== "@angular/core" || imp.name !== "forwardRef") {
+    return null;
+  }
+  return expr;
+}
+function forwardRefResolver(ref, args) {
+  if (!isAngularCoreReference(ref, "forwardRef") || args.length !== 1) {
+    return null;
+  }
+  return expandForwardRef(args[0]);
+}
+function combineResolvers(resolvers) {
+  return (ref, args) => {
+    for (const resolver of resolvers) {
+      const resolved = resolver(ref, args);
+      if (resolved !== null) {
+        return resolved;
+      }
+    }
+    return null;
+  };
+}
+function isExpressionForwardReference(expr, context, contextSource) {
+  if (isWrappedTsNodeExpr(expr)) {
+    const node = ts.getOriginalNode(expr.node);
+    return node.getSourceFile() === contextSource && context.pos < node.pos;
+  } else {
+    return false;
+  }
+}
+function isWrappedTsNodeExpr(expr) {
+  return expr instanceof WrappedNodeExpr;
+}
+function readBaseClass(node, reflector, evaluator) {
+  const baseExpression = reflector.getBaseClassExpression(node);
+  if (baseExpression !== null) {
+    const baseClass = evaluator.evaluate(baseExpression);
+    if (baseClass instanceof Reference && reflector.isClass(baseClass.node)) {
+      return baseClass;
+    } else {
+      return "dynamic";
+    }
+  }
+  return null;
+}
+var parensWrapperTransformerFactory = (context) => {
+  const visitor = (node) => {
+    const visited = ts.visitEachChild(node, visitor, context);
+    if (ts.isArrowFunction(visited) || ts.isFunctionExpression(visited)) {
+      return ts.factory.createParenthesizedExpression(visited);
+    }
+    return visited;
+  };
+  return (node) => ts.visitEachChild(node, visitor, context);
+};
+function wrapFunctionExpressionsInParens(expression) {
+  return ts.transform(expression, [parensWrapperTransformerFactory]).transformed[0];
+}
+function resolveProvidersRequiringFactory(rawProviders, reflector, evaluator) {
+  const providers = /* @__PURE__ */ new Set();
+  const resolvedProviders = evaluator.evaluate(rawProviders);
+  if (!Array.isArray(resolvedProviders)) {
+    return providers;
+  }
+  resolvedProviders.forEach(function processProviders(provider) {
+    let tokenClass = null;
+    if (Array.isArray(provider)) {
+      provider.forEach(processProviders);
+    } else if (provider instanceof Reference) {
+      tokenClass = provider;
+    } else if (provider instanceof Map && provider.has("useClass") && !provider.has("deps")) {
+      const useExisting = provider.get("useClass");
+      if (useExisting instanceof Reference) {
+        tokenClass = useExisting;
+      }
+    }
+    if (tokenClass !== null && !tokenClass.node.getSourceFile().isDeclarationFile && reflector.isClass(tokenClass.node)) {
+      const constructorParameters = reflector.getConstructorParameters(tokenClass.node);
+      if (constructorParameters !== null && constructorParameters.length > 0) {
+        providers.add(tokenClass);
+      }
+    }
+  });
+  return providers;
+}
+function wrapTypeReference(reflector, clazz) {
+  const dtsClass = reflector.getDtsDeclaration(clazz);
+  const value = new WrappedNodeExpr(clazz.name);
+  const type = dtsClass !== null && isNamedClassDeclaration(dtsClass) ? new WrappedNodeExpr(dtsClass.name) : value;
+  return { value, type };
+}
+function createSourceSpan(node) {
+  const sf = node.getSourceFile();
+  const [startOffset, endOffset] = [node.getStart(), node.getEnd()];
+  const { line: startLine, character: startCol } = sf.getLineAndCharacterOfPosition(startOffset);
+  const { line: endLine, character: endCol } = sf.getLineAndCharacterOfPosition(endOffset);
+  const parseSf = new ParseSourceFile(sf.getFullText(), sf.fileName);
+  return new ParseSourceSpan(new ParseLocation(parseSf, startOffset, startLine + 1, startCol + 1), new ParseLocation(parseSf, endOffset, endLine + 1, endCol + 1));
+}
+function compileResults(fac, def, metadataStmt, propName) {
+  const statements = def.statements;
+  if (metadataStmt !== null) {
+    statements.push(metadataStmt);
+  }
+  return [
+    fac,
+    {
+      name: propName,
+      initializer: def.expression,
+      statements: def.statements,
+      type: def.type
+    }
+  ];
+}
+function toFactoryMetadata(meta, target) {
+  return {
+    name: meta.name,
+    type: meta.type,
+    internalType: meta.internalType,
+    typeArgumentCount: meta.typeArgumentCount,
+    deps: meta.deps,
+    target
+  };
+}
+function resolveImportedFile(moduleResolver, importedFile, expr, origin) {
+  if (importedFile !== "unknown") {
+    return importedFile;
+  }
+  if (!(expr instanceof ExternalExpr)) {
+    return null;
+  }
+  return moduleResolver.resolveModule(expr.value.moduleName, origin.fileName);
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/dynamic.mjs
 var DynamicValue = class {
   constructor(node, reason, code) {
@@ -137,7 +359,7 @@ var DynamicValue = class {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.mjs
-import ts from "typescript";
+import ts2 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/result.mjs
 var ResolvedModule = class {
@@ -325,34 +547,34 @@ function referenceBinaryOp(op) {
   return { op, literal: false };
 }
 var BINARY_OPERATORS = /* @__PURE__ */ new Map([
-  [ts.SyntaxKind.PlusToken, literalBinaryOp((a, b) => a + b)],
-  [ts.SyntaxKind.MinusToken, literalBinaryOp((a, b) => a - b)],
-  [ts.SyntaxKind.AsteriskToken, literalBinaryOp((a, b) => a * b)],
-  [ts.SyntaxKind.SlashToken, literalBinaryOp((a, b) => a / b)],
-  [ts.SyntaxKind.PercentToken, literalBinaryOp((a, b) => a % b)],
-  [ts.SyntaxKind.AmpersandToken, literalBinaryOp((a, b) => a & b)],
-  [ts.SyntaxKind.BarToken, literalBinaryOp((a, b) => a | b)],
-  [ts.SyntaxKind.CaretToken, literalBinaryOp((a, b) => a ^ b)],
-  [ts.SyntaxKind.LessThanToken, literalBinaryOp((a, b) => a < b)],
-  [ts.SyntaxKind.LessThanEqualsToken, literalBinaryOp((a, b) => a <= b)],
-  [ts.SyntaxKind.GreaterThanToken, literalBinaryOp((a, b) => a > b)],
-  [ts.SyntaxKind.GreaterThanEqualsToken, literalBinaryOp((a, b) => a >= b)],
-  [ts.SyntaxKind.EqualsEqualsToken, literalBinaryOp((a, b) => a == b)],
-  [ts.SyntaxKind.EqualsEqualsEqualsToken, literalBinaryOp((a, b) => a === b)],
-  [ts.SyntaxKind.ExclamationEqualsToken, literalBinaryOp((a, b) => a != b)],
-  [ts.SyntaxKind.ExclamationEqualsEqualsToken, literalBinaryOp((a, b) => a !== b)],
-  [ts.SyntaxKind.LessThanLessThanToken, literalBinaryOp((a, b) => a << b)],
-  [ts.SyntaxKind.GreaterThanGreaterThanToken, literalBinaryOp((a, b) => a >> b)],
-  [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, literalBinaryOp((a, b) => a >>> b)],
-  [ts.SyntaxKind.AsteriskAsteriskToken, literalBinaryOp((a, b) => Math.pow(a, b))],
-  [ts.SyntaxKind.AmpersandAmpersandToken, referenceBinaryOp((a, b) => a && b)],
-  [ts.SyntaxKind.BarBarToken, referenceBinaryOp((a, b) => a || b)]
+  [ts2.SyntaxKind.PlusToken, literalBinaryOp((a, b) => a + b)],
+  [ts2.SyntaxKind.MinusToken, literalBinaryOp((a, b) => a - b)],
+  [ts2.SyntaxKind.AsteriskToken, literalBinaryOp((a, b) => a * b)],
+  [ts2.SyntaxKind.SlashToken, literalBinaryOp((a, b) => a / b)],
+  [ts2.SyntaxKind.PercentToken, literalBinaryOp((a, b) => a % b)],
+  [ts2.SyntaxKind.AmpersandToken, literalBinaryOp((a, b) => a & b)],
+  [ts2.SyntaxKind.BarToken, literalBinaryOp((a, b) => a | b)],
+  [ts2.SyntaxKind.CaretToken, literalBinaryOp((a, b) => a ^ b)],
+  [ts2.SyntaxKind.LessThanToken, literalBinaryOp((a, b) => a < b)],
+  [ts2.SyntaxKind.LessThanEqualsToken, literalBinaryOp((a, b) => a <= b)],
+  [ts2.SyntaxKind.GreaterThanToken, literalBinaryOp((a, b) => a > b)],
+  [ts2.SyntaxKind.GreaterThanEqualsToken, literalBinaryOp((a, b) => a >= b)],
+  [ts2.SyntaxKind.EqualsEqualsToken, literalBinaryOp((a, b) => a == b)],
+  [ts2.SyntaxKind.EqualsEqualsEqualsToken, literalBinaryOp((a, b) => a === b)],
+  [ts2.SyntaxKind.ExclamationEqualsToken, literalBinaryOp((a, b) => a != b)],
+  [ts2.SyntaxKind.ExclamationEqualsEqualsToken, literalBinaryOp((a, b) => a !== b)],
+  [ts2.SyntaxKind.LessThanLessThanToken, literalBinaryOp((a, b) => a << b)],
+  [ts2.SyntaxKind.GreaterThanGreaterThanToken, literalBinaryOp((a, b) => a >> b)],
+  [ts2.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, literalBinaryOp((a, b) => a >>> b)],
+  [ts2.SyntaxKind.AsteriskAsteriskToken, literalBinaryOp((a, b) => Math.pow(a, b))],
+  [ts2.SyntaxKind.AmpersandAmpersandToken, referenceBinaryOp((a, b) => a && b)],
+  [ts2.SyntaxKind.BarBarToken, referenceBinaryOp((a, b) => a || b)]
 ]);
 var UNARY_OPERATORS = /* @__PURE__ */ new Map([
-  [ts.SyntaxKind.TildeToken, (a) => ~a],
-  [ts.SyntaxKind.MinusToken, (a) => -a],
-  [ts.SyntaxKind.PlusToken, (a) => +a],
-  [ts.SyntaxKind.ExclamationToken, (a) => !a]
+  [ts2.SyntaxKind.TildeToken, (a) => ~a],
+  [ts2.SyntaxKind.MinusToken, (a) => -a],
+  [ts2.SyntaxKind.PlusToken, (a) => +a],
+  [ts2.SyntaxKind.ExclamationToken, (a) => !a]
 ]);
 var StaticInterpreter = class {
   constructor(host, checker, dependencyTracker) {
@@ -365,43 +587,43 @@ var StaticInterpreter = class {
   }
   visitExpression(node, context) {
     let result;
-    if (node.kind === ts.SyntaxKind.TrueKeyword) {
+    if (node.kind === ts2.SyntaxKind.TrueKeyword) {
       return true;
-    } else if (node.kind === ts.SyntaxKind.FalseKeyword) {
+    } else if (node.kind === ts2.SyntaxKind.FalseKeyword) {
       return false;
-    } else if (node.kind === ts.SyntaxKind.NullKeyword) {
+    } else if (node.kind === ts2.SyntaxKind.NullKeyword) {
       return null;
-    } else if (ts.isStringLiteral(node)) {
+    } else if (ts2.isStringLiteral(node)) {
       return node.text;
-    } else if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    } else if (ts2.isNoSubstitutionTemplateLiteral(node)) {
       return node.text;
-    } else if (ts.isTemplateExpression(node)) {
+    } else if (ts2.isTemplateExpression(node)) {
       result = this.visitTemplateExpression(node, context);
-    } else if (ts.isNumericLiteral(node)) {
+    } else if (ts2.isNumericLiteral(node)) {
       return parseFloat(node.text);
-    } else if (ts.isObjectLiteralExpression(node)) {
+    } else if (ts2.isObjectLiteralExpression(node)) {
       result = this.visitObjectLiteralExpression(node, context);
-    } else if (ts.isIdentifier(node)) {
+    } else if (ts2.isIdentifier(node)) {
       result = this.visitIdentifier(node, context);
-    } else if (ts.isPropertyAccessExpression(node)) {
+    } else if (ts2.isPropertyAccessExpression(node)) {
       result = this.visitPropertyAccessExpression(node, context);
-    } else if (ts.isCallExpression(node)) {
+    } else if (ts2.isCallExpression(node)) {
       result = this.visitCallExpression(node, context);
-    } else if (ts.isConditionalExpression(node)) {
+    } else if (ts2.isConditionalExpression(node)) {
       result = this.visitConditionalExpression(node, context);
-    } else if (ts.isPrefixUnaryExpression(node)) {
+    } else if (ts2.isPrefixUnaryExpression(node)) {
       result = this.visitPrefixUnaryExpression(node, context);
-    } else if (ts.isBinaryExpression(node)) {
+    } else if (ts2.isBinaryExpression(node)) {
       result = this.visitBinaryExpression(node, context);
-    } else if (ts.isArrayLiteralExpression(node)) {
+    } else if (ts2.isArrayLiteralExpression(node)) {
       result = this.visitArrayLiteralExpression(node, context);
-    } else if (ts.isParenthesizedExpression(node)) {
+    } else if (ts2.isParenthesizedExpression(node)) {
       result = this.visitParenthesizedExpression(node, context);
-    } else if (ts.isElementAccessExpression(node)) {
+    } else if (ts2.isElementAccessExpression(node)) {
       result = this.visitElementAccessExpression(node, context);
-    } else if (ts.isAsExpression(node)) {
+    } else if (ts2.isAsExpression(node)) {
       result = this.visitExpression(node.expression, context);
-    } else if (ts.isNonNullExpression(node)) {
+    } else if (ts2.isNonNullExpression(node)) {
       result = this.visitExpression(node.expression, context);
     } else if (this.host.isClass(node)) {
       result = this.visitDeclaration(node, context);
@@ -417,7 +639,7 @@ var StaticInterpreter = class {
     const array = [];
     for (let i = 0; i < node.elements.length; i++) {
       const element = node.elements[i];
-      if (ts.isSpreadElement(element)) {
+      if (ts2.isSpreadElement(element)) {
         array.push(...this.visitSpreadElement(element, context));
       } else {
         array.push(this.visitExpression(element, context));
@@ -429,20 +651,20 @@ var StaticInterpreter = class {
     const map = /* @__PURE__ */ new Map();
     for (let i = 0; i < node.properties.length; i++) {
       const property = node.properties[i];
-      if (ts.isPropertyAssignment(property)) {
+      if (ts2.isPropertyAssignment(property)) {
         const name = this.stringNameFromPropertyName(property.name, context);
         if (name === void 0) {
           return DynamicValue.fromDynamicInput(node, DynamicValue.fromDynamicString(property.name));
         }
         map.set(name, this.visitExpression(property.initializer, context));
-      } else if (ts.isShorthandPropertyAssignment(property)) {
+      } else if (ts2.isShorthandPropertyAssignment(property)) {
         const symbol = this.checker.getShorthandAssignmentValueSymbol(property);
         if (symbol === void 0 || symbol.valueDeclaration === void 0) {
           map.set(property.name.text, DynamicValue.fromUnknown(property));
         } else {
           map.set(property.name.text, this.visitDeclaration(symbol.valueDeclaration, context));
         }
-      } else if (ts.isSpreadAssignment(property)) {
+      } else if (ts2.isSpreadAssignment(property)) {
         const spread = this.visitExpression(property.expression, context);
         if (spread instanceof DynamicValue) {
           return DynamicValue.fromDynamicInput(node, spread);
@@ -474,7 +696,7 @@ var StaticInterpreter = class {
   visitIdentifier(node, context) {
     const decl = this.host.getDeclarationOfIdentifier(node);
     if (decl === null) {
-      if (node.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
+      if (node.originalKeywordKind === ts2.SyntaxKind.UndefinedKeyword) {
         return void 0;
       } else {
         if (this.dependencyTracker !== null && this.host.getImportOfIdentifier(node) !== null) {
@@ -505,17 +727,17 @@ var StaticInterpreter = class {
     }
     if (this.host.isClass(node)) {
       return this.getReference(node, context);
-    } else if (ts.isVariableDeclaration(node)) {
+    } else if (ts2.isVariableDeclaration(node)) {
       return this.visitVariableDeclaration(node, context);
-    } else if (ts.isParameter(node) && context.scope.has(node)) {
+    } else if (ts2.isParameter(node) && context.scope.has(node)) {
       return context.scope.get(node);
-    } else if (ts.isExportAssignment(node)) {
+    } else if (ts2.isExportAssignment(node)) {
       return this.visitExpression(node.expression, context);
-    } else if (ts.isEnumDeclaration(node)) {
+    } else if (ts2.isEnumDeclaration(node)) {
       return this.visitEnumDeclaration(node, context);
-    } else if (ts.isSourceFile(node)) {
+    } else if (ts2.isSourceFile(node)) {
       return this.visitSourceFile(node, context);
-    } else if (ts.isBindingElement(node)) {
+    } else if (ts2.isBindingElement(node)) {
       return this.visitBindingElement(node, context);
     } else {
       return this.getReference(node, context);
@@ -691,7 +913,7 @@ var StaticInterpreter = class {
   visitFunctionBody(node, fn, context) {
     if (fn.body === null) {
       return DynamicValue.fromUnknown(node);
-    } else if (fn.body.length !== 1 || !ts.isReturnStatement(fn.body[0])) {
+    } else if (fn.body.length !== 1 || !ts2.isReturnStatement(fn.body[0])) {
       return DynamicValue.fromComplexFunctionCall(node, fn);
     }
     const ret = fn.body[0];
@@ -762,7 +984,7 @@ var StaticInterpreter = class {
   evaluateFunctionArguments(node, context) {
     const args = [];
     for (const arg of node.arguments) {
-      if (ts.isSpreadElement(arg)) {
+      if (ts2.isSpreadElement(arg)) {
         args.push(...this.visitSpreadElement(arg, context));
       } else {
         args.push(this.visitExpression(arg, context));
@@ -783,23 +1005,23 @@ var StaticInterpreter = class {
   visitBindingElement(node, context) {
     const path = [];
     let closestDeclaration = node;
-    while (ts.isBindingElement(closestDeclaration) || ts.isArrayBindingPattern(closestDeclaration) || ts.isObjectBindingPattern(closestDeclaration)) {
-      if (ts.isBindingElement(closestDeclaration)) {
+    while (ts2.isBindingElement(closestDeclaration) || ts2.isArrayBindingPattern(closestDeclaration) || ts2.isObjectBindingPattern(closestDeclaration)) {
+      if (ts2.isBindingElement(closestDeclaration)) {
         path.unshift(closestDeclaration);
       }
       closestDeclaration = closestDeclaration.parent;
     }
-    if (!ts.isVariableDeclaration(closestDeclaration) || closestDeclaration.initializer === void 0) {
+    if (!ts2.isVariableDeclaration(closestDeclaration) || closestDeclaration.initializer === void 0) {
       return DynamicValue.fromUnknown(node);
     }
     let value = this.visit(closestDeclaration.initializer, context);
     for (const element of path) {
       let key;
-      if (ts.isArrayBindingPattern(element.parent)) {
+      if (ts2.isArrayBindingPattern(element.parent)) {
         key = element.parent.elements.indexOf(element);
       } else {
         const name = element.propertyName || element.name;
-        if (ts.isIdentifier(name)) {
+        if (ts2.isIdentifier(name)) {
           key = name.text;
         } else {
           return DynamicValue.fromUnknown(element);
@@ -813,9 +1035,9 @@ var StaticInterpreter = class {
     return value;
   }
   stringNameFromPropertyName(node, context) {
-    if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) {
+    if (ts2.isIdentifier(node) || ts2.isStringLiteral(node) || ts2.isNumericLiteral(node)) {
       return node.text;
-    } else if (ts.isComputedPropertyName(node)) {
+    } else if (ts2.isComputedPropertyName(node)) {
       const literal2 = this.visitExpression(node.expression, context);
       return typeof literal2 === "string" ? literal2 : void 0;
     } else {
@@ -838,11 +1060,11 @@ var StaticInterpreter = class {
     return new Reference(node, owningModule(context));
   }
   visitType(node, context) {
-    if (ts.isLiteralTypeNode(node)) {
+    if (ts2.isLiteralTypeNode(node)) {
       return this.visitExpression(node.literal, context);
-    } else if (ts.isTupleTypeNode(node)) {
+    } else if (ts2.isTupleTypeNode(node)) {
       return this.visitTupleType(node, context);
-    } else if (ts.isNamedTupleMember(node)) {
+    } else if (ts2.isNamedTupleMember(node)) {
       return this.visitType(node.type, context);
     }
     return DynamicValue.fromDynamicType(node);
@@ -856,7 +1078,7 @@ var StaticInterpreter = class {
   }
 };
 function isFunctionOrMethodReference(ref) {
-  return ts.isFunctionDeclaration(ref.node) || ts.isMethodDeclaration(ref.node) || ts.isFunctionExpression(ref.node);
+  return ts2.isFunctionDeclaration(ref.node) || ts2.isMethodDeclaration(ref.node) || ts2.isFunctionExpression(ref.node);
 }
 function literal(value, reject) {
   if (value instanceof EnumValue) {
@@ -868,15 +1090,15 @@ function literal(value, reject) {
   return reject(value);
 }
 function isVariableDeclarationDeclared(node) {
-  if (node.parent === void 0 || !ts.isVariableDeclarationList(node.parent)) {
+  if (node.parent === void 0 || !ts2.isVariableDeclarationList(node.parent)) {
     return false;
   }
   const declList = node.parent;
-  if (declList.parent === void 0 || !ts.isVariableStatement(declList.parent)) {
+  if (declList.parent === void 0 || !ts2.isVariableStatement(declList.parent)) {
     return false;
   }
   const varStmt = declList.parent;
-  return varStmt.modifiers !== void 0 && varStmt.modifiers.some((mod) => mod.kind === ts.SyntaxKind.DeclareKeyword);
+  return varStmt.modifiers !== void 0 && varStmt.modifiers.some((mod) => mod.kind === ts2.SyntaxKind.DeclareKeyword);
 }
 var EMPTY = {};
 function joinModuleContext(existing, node, decl) {
@@ -925,7 +1147,7 @@ var PartialEvaluator = class {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/diagnostics.mjs
-import ts2 from "typescript";
+import ts3 from "typescript";
 function describeResolvedType(value, maxDepth = 1) {
   var _a, _b;
   if (value === null) {
@@ -1029,21 +1251,21 @@ function getContainerNode(node) {
   let currentNode = node;
   while (currentNode !== void 0) {
     switch (currentNode.kind) {
-      case ts2.SyntaxKind.ExpressionStatement:
-      case ts2.SyntaxKind.VariableStatement:
-      case ts2.SyntaxKind.ReturnStatement:
-      case ts2.SyntaxKind.IfStatement:
-      case ts2.SyntaxKind.SwitchStatement:
-      case ts2.SyntaxKind.DoStatement:
-      case ts2.SyntaxKind.WhileStatement:
-      case ts2.SyntaxKind.ForStatement:
-      case ts2.SyntaxKind.ForInStatement:
-      case ts2.SyntaxKind.ForOfStatement:
-      case ts2.SyntaxKind.ContinueStatement:
-      case ts2.SyntaxKind.BreakStatement:
-      case ts2.SyntaxKind.ThrowStatement:
-      case ts2.SyntaxKind.ObjectBindingPattern:
-      case ts2.SyntaxKind.ArrayBindingPattern:
+      case ts3.SyntaxKind.ExpressionStatement:
+      case ts3.SyntaxKind.VariableStatement:
+      case ts3.SyntaxKind.ReturnStatement:
+      case ts3.SyntaxKind.IfStatement:
+      case ts3.SyntaxKind.SwitchStatement:
+      case ts3.SyntaxKind.DoStatement:
+      case ts3.SyntaxKind.WhileStatement:
+      case ts3.SyntaxKind.ForStatement:
+      case ts3.SyntaxKind.ForInStatement:
+      case ts3.SyntaxKind.ForOfStatement:
+      case ts3.SyntaxKind.ContinueStatement:
+      case ts3.SyntaxKind.BreakStatement:
+      case ts3.SyntaxKind.ThrowStatement:
+      case ts3.SyntaxKind.ObjectBindingPattern:
+      case ts3.SyntaxKind.ArrayBindingPattern:
         return currentNode;
     }
     currentNode = currentNode.parent;
@@ -1051,9 +1273,9 @@ function getContainerNode(node) {
   return node.getSourceFile();
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/util.mjs
-import { ExternalExpr, LiteralExpr, ParseLocation, ParseSourceFile, ParseSourceSpan, ReadPropExpr, WrappedNodeExpr } from "@angular/compiler";
-import ts3 from "typescript";
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/di.mjs
+import { LiteralExpr, WrappedNodeExpr as WrappedNodeExpr2 } from "@angular/compiler";
+import ts4 from "typescript";
 function getConstructorDependencies(clazz, reflector, isCore) {
   const deps = [];
   const errors = [];
@@ -1075,7 +1297,7 @@ function getConstructorDependencies(clazz, reflector, isCore) {
         if (dec.args === null || dec.args.length !== 1) {
           throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(dec), `Unexpected number of arguments to @Inject().`);
         }
-        token = new WrappedNodeExpr(dec.args[0]);
+        token = new WrappedNodeExpr2(dec.args[0]);
       } else if (name === "Optional") {
         optional = true;
       } else if (name === "SkipSelf") {
@@ -1089,11 +1311,11 @@ function getConstructorDependencies(clazz, reflector, isCore) {
           throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(dec), `Unexpected number of arguments to @Attribute().`);
         }
         const attributeName = dec.args[0];
-        token = new WrappedNodeExpr(attributeName);
-        if (ts3.isStringLiteralLike(attributeName)) {
+        token = new WrappedNodeExpr2(attributeName);
+        if (ts4.isStringLiteralLike(attributeName)) {
           attributeNameType = new LiteralExpr(attributeName.text);
         } else {
-          attributeNameType = new WrappedNodeExpr(ts3.createKeywordTypeNode(ts3.SyntaxKind.UnknownKeyword));
+          attributeNameType = new WrappedNodeExpr2(ts4.factory.createKeywordTypeNode(ts4.SyntaxKind.UnknownKeyword));
         }
       } else {
         throw new FatalDiagnosticError(ErrorCode.DECORATOR_UNEXPECTED, Decorator.nodeForError(dec), `Unexpected decorator ${name} on parameter.`);
@@ -1118,25 +1340,6 @@ function getConstructorDependencies(clazz, reflector, isCore) {
     return { deps: null, errors };
   }
 }
-function valueReferenceToExpression(valueRef) {
-  if (valueRef.kind === 2) {
-    return null;
-  } else if (valueRef.kind === 0) {
-    const expr = new WrappedNodeExpr(valueRef.expression);
-    if (valueRef.defaultImportStatement !== null) {
-      attachDefaultImportDeclaration(expr, valueRef.defaultImportStatement);
-    }
-    return expr;
-  } else {
-    let importExpr = new ExternalExpr({ moduleName: valueRef.moduleName, name: valueRef.importedName });
-    if (valueRef.nestedPath !== null) {
-      for (const property of valueRef.nestedPath) {
-        importExpr = new ReadPropExpr(importExpr, property);
-      }
-    }
-    return importExpr;
-  }
-}
 function unwrapConstructorDependencies(deps) {
   if (deps === null) {
     return null;
@@ -1203,224 +1406,269 @@ function createUnsuitableInjectionTokenError(clazz, error) {
   }
   const chain = {
     messageText: `No suitable injection token for parameter '${param.name || index}' of class '${clazz.name.text}'.`,
-    category: ts3.DiagnosticCategory.Error,
+    category: ts4.DiagnosticCategory.Error,
     code: 0,
     next: [{
       messageText: chainMessage,
-      category: ts3.DiagnosticCategory.Message,
+      category: ts4.DiagnosticCategory.Message,
       code: 0
     }]
   };
   return new FatalDiagnosticError(ErrorCode.PARAM_MISSING_TOKEN, param.nameNode, chain, hints);
 }
-function toR3Reference(origin, valueRef, typeRef, valueContext, typeContext, refEmitter) {
-  const emittedValueRef = refEmitter.emit(valueRef, valueContext);
-  assertSuccessfulReferenceEmit(emittedValueRef, origin, "class");
-  const emittedTypeRef = refEmitter.emit(typeRef, typeContext, ImportFlags.ForceNewImport | ImportFlags.AllowTypeImports);
-  assertSuccessfulReferenceEmit(emittedTypeRef, origin, "class");
-  return {
-    value: emittedValueRef.expression,
-    type: emittedTypeRef.expression
-  };
-}
-function isAngularCore(decorator) {
-  return decorator.import !== null && decorator.import.from === "@angular/core";
-}
-function isAngularCoreReference(reference, symbolName) {
-  return reference.ownedByModuleGuess === "@angular/core" && reference.debugName === symbolName;
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/diagnostics.mjs
+import ts5 from "typescript";
+function makeDuplicateDeclarationError(node, data, kind) {
+  const context = [];
+  for (const decl of data) {
+    if (decl.rawDeclarations === null) {
+      continue;
+    }
+    const contextNode = decl.ref.getOriginForDiagnostics(decl.rawDeclarations, decl.ngModule.name);
+    context.push(makeRelatedInformation(contextNode, `'${node.name.text}' is listed in the declarations of the NgModule '${decl.ngModule.name.text}'.`));
+  }
+  return makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_NOT_UNIQUE, node.name, `The ${kind} '${node.name.text}' is declared by more than one NgModule.`, context);
 }
-function findAngularDecorator(decorators, name, isCore) {
-  return decorators.find((decorator) => isAngularDecorator(decorator, name, isCore));
+function createValueHasWrongTypeError(node, value, messageText) {
+  var _a;
+  let chainedMessage;
+  let relatedInformation;
+  if (value instanceof DynamicValue) {
+    chainedMessage = "Value could not be determined statically.";
+    relatedInformation = traceDynamicValue(node, value);
+  } else if (value instanceof Reference) {
+    const target = value.debugName !== null ? `'${value.debugName}'` : "an anonymous declaration";
+    chainedMessage = `Value is a reference to ${target}.`;
+    const referenceNode = (_a = identifierOfNode(value.node)) != null ? _a : value.node;
+    relatedInformation = [makeRelatedInformation(referenceNode, "Reference is declared here.")];
+  } else {
+    chainedMessage = `Value is of type '${describeResolvedType(value)}'.`;
+  }
+  const chain = {
+    messageText,
+    category: ts5.DiagnosticCategory.Error,
+    code: 0,
+    next: [{
+      messageText: chainedMessage,
+      category: ts5.DiagnosticCategory.Message,
+      code: 0
+    }]
+  };
+  return new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, node, chain, relatedInformation);
 }
-function isAngularDecorator(decorator, name, isCore) {
-  if (isCore) {
-    return decorator.name === name;
-  } else if (isAngularCore(decorator)) {
-    return decorator.import.name === name;
+function getProviderDiagnostics(providerClasses, providersDeclaration, registry) {
+  const diagnostics = [];
+  for (const provider of providerClasses) {
+    if (registry.isInjectable(provider.node)) {
+      continue;
+    }
+    const contextNode = provider.getOriginForDiagnostics(providersDeclaration);
+    diagnostics.push(makeDiagnostic(ErrorCode.UNDECORATED_PROVIDER, contextNode, `The class '${provider.node.name.text}' cannot be created via dependency injection, as it does not have an Angular decorator. This will result in an error at runtime.
+
+Either add the @Injectable() decorator to '${provider.node.name.text}', or configure a different provider (such as a provider with 'useFactory').
+`, [makeRelatedInformation(provider.node, `'${provider.node.name.text}' is declared here.`)]));
   }
-  return false;
+  return diagnostics;
 }
-function unwrapExpression(node) {
-  while (ts3.isAsExpression(node) || ts3.isParenthesizedExpression(node)) {
-    node = node.expression;
+function getDirectiveDiagnostics(node, reader, evaluator, reflector, scopeRegistry, kind) {
+  let diagnostics = [];
+  const addDiagnostics = (more) => {
+    if (more === null) {
+      return;
+    } else if (diagnostics === null) {
+      diagnostics = Array.isArray(more) ? more : [more];
+    } else if (Array.isArray(more)) {
+      diagnostics.push(...more);
+    } else {
+      diagnostics.push(more);
+    }
+  };
+  const duplicateDeclarations = scopeRegistry.getDuplicateDeclarations(node);
+  if (duplicateDeclarations !== null) {
+    addDiagnostics(makeDuplicateDeclarationError(node, duplicateDeclarations, kind));
   }
-  return node;
+  addDiagnostics(checkInheritanceOfDirective(node, reader, reflector, evaluator));
+  return diagnostics;
 }
-function expandForwardRef(arg) {
-  arg = unwrapExpression(arg);
-  if (!ts3.isArrowFunction(arg) && !ts3.isFunctionExpression(arg)) {
+function getUndecoratedClassWithAngularFeaturesDiagnostic(node) {
+  return makeDiagnostic(ErrorCode.UNDECORATED_CLASS_USING_ANGULAR_FEATURES, node.name, `Class is using Angular features but is not decorated. Please add an explicit Angular decorator.`);
+}
+function checkInheritanceOfDirective(node, reader, reflector, evaluator) {
+  if (!reflector.isClass(node) || reflector.getConstructorParameters(node) !== null) {
     return null;
   }
-  const body = arg.body;
-  if (ts3.isBlock(body)) {
-    if (body.statements.length !== 1) {
+  let baseClass = readBaseClass(node, reflector, evaluator);
+  while (baseClass !== null) {
+    if (baseClass === "dynamic") {
       return null;
     }
-    const stmt = body.statements[0];
-    if (!ts3.isReturnStatement(stmt) || stmt.expression === void 0) {
+    const baseClassMeta = reader.getDirectiveMetadata(baseClass);
+    if (baseClassMeta !== null) {
       return null;
     }
-    return stmt.expression;
-  } else {
-    return body;
+    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;
+    }
+    baseClass = newParentClass;
   }
+  return null;
 }
-function tryUnwrapForwardRef(node, reflector) {
-  node = unwrapExpression(node);
-  if (!ts3.isCallExpression(node) || node.arguments.length !== 1) {
-    return null;
+function getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader) {
+  const subclassMeta = reader.getDirectiveMetadata(new Reference(node));
+  const dirOrComp = subclassMeta.isComponent ? "Component" : "Directive";
+  const baseClassName = baseClass.debugName;
+  return makeDiagnostic(ErrorCode.DIRECTIVE_INHERITS_UNDECORATED_CTOR, node.name, `The ${dirOrComp.toLowerCase()} ${node.name.text} inherits its constructor from ${baseClassName}, but the latter does not have an Angular decorator of its own. Dependency injection will not be able to resolve the parameters of ${baseClassName}'s constructor. Either add a @Directive decorator to ${baseClassName}, or add an explicit constructor to ${node.name.text}.`);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/evaluation.mjs
+import ts6 from "typescript";
+function resolveEnumValue(evaluator, metadata, field, enumSymbolName) {
+  let resolved = null;
+  if (metadata.has(field)) {
+    const expr = metadata.get(field);
+    const value = evaluator.evaluate(expr);
+    if (value instanceof EnumValue && isAngularCoreReference(value.enumRef, enumSymbolName)) {
+      resolved = value.resolved;
+    } else {
+      throw createValueHasWrongTypeError(expr, value, `${field} must be a member of ${enumSymbolName} enum from @angular/core`);
+    }
   }
-  const fn = ts3.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression;
-  if (!ts3.isIdentifier(fn)) {
-    return null;
+  return resolved;
+}
+function isStringArray(resolvedValue) {
+  return Array.isArray(resolvedValue) && resolvedValue.every((elem) => typeof elem === "string");
+}
+function resolveLiteral(decorator, literalCache) {
+  if (literalCache.has(decorator)) {
+    return literalCache.get(decorator);
   }
-  const expr = expandForwardRef(node.arguments[0]);
-  if (expr === null) {
-    return null;
+  if (decorator.args === null || decorator.args.length !== 1) {
+    throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @${decorator.name} decorator`);
   }
-  const imp = reflector.getImportOfIdentifier(fn);
-  if (imp === null || imp.from !== "@angular/core" || imp.name !== "forwardRef") {
-    return null;
+  const meta = unwrapExpression(decorator.args[0]);
+  if (!ts6.isObjectLiteralExpression(meta)) {
+    throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `Decorator argument must be literal.`);
   }
-  return expr;
+  literalCache.set(decorator, meta);
+  return meta;
 }
-function forwardRefResolver(ref, args) {
-  if (!isAngularCoreReference(ref, "forwardRef") || args.length !== 1) {
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/factory.mjs
+import { compileDeclareFactoryFunction, compileFactoryFunction } from "@angular/compiler";
+function compileNgFactoryDefField(metadata) {
+  const res = compileFactoryFunction(metadata);
+  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
+}
+function compileDeclareFactory(metadata) {
+  const res = compileDeclareFactoryFunction(metadata);
+  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
+}
+
+// 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;
   }
-  return expandForwardRef(args[0]);
-}
-function combineResolvers(resolvers) {
-  return (ref, args) => {
-    for (const resolver of resolvers) {
-      const resolved = resolver(ref, args);
-      if (resolved !== null) {
-        return resolved;
-      }
-    }
+  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(ts7.factory.createArrayLiteralExpression(ngClassDecorators));
+  let metaCtorParameters = null;
+  const classCtorParameters = reflection.getConstructorParameters(clazz);
+  if (classCtorParameters !== null) {
+    const ctorParameters = classCtorParameters.map((param) => ctorParameterToMetadata(param, isCore));
+    metaCtorParameters = new FunctionExpr([], [
+      new ReturnStatement(new LiteralArrayExpr(ctorParameters))
+    ]);
+  }
+  let metaPropDecorators = null;
+  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && member.decorators !== null && member.decorators.length > 0);
+  const duplicateDecoratedMemberNames = classMembers.map((member) => member.name).filter((name, i, arr) => arr.indexOf(name) < i);
+  if (duplicateDecoratedMemberNames.length > 0) {
+    throw new Error(`Duplicate decorated properties found on class '${clazz.name.text}': ` + duplicateDecoratedMemberNames.join(", "));
+  }
+  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));
+  }
+  return {
+    type: new WrappedNodeExpr3(id),
+    decorators: metaDecorators,
+    ctorParameters: metaCtorParameters,
+    propDecorators: metaPropDecorators
   };
 }
-function isExpressionForwardReference(expr, context, contextSource) {
-  if (isWrappedTsNodeExpr(expr)) {
-    const node = ts3.getOriginalNode(expr.node);
-    return node.getSourceFile() === contextSource && context.pos < node.pos;
-  } else {
-    return false;
+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 });
   }
+  return literalMap(mapEntries);
 }
-function isWrappedTsNodeExpr(expr) {
-  return expr instanceof WrappedNodeExpr;
+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 readBaseClass(node, reflector, evaluator) {
-  const baseExpression = reflector.getBaseClassExpression(node);
-  if (baseExpression !== null) {
-    const baseClass = evaluator.evaluate(baseExpression);
-    if (baseClass instanceof Reference && reflector.isClass(baseClass.node)) {
-      return baseClass;
-    } else {
-      return "dynamic";
-    }
+function decoratorToMetadata(decorator, wrapFunctionsInParens) {
+  if (decorator.identifier === null) {
+    throw new Error("Illegal state: synthesized decorator cannot be emitted in class metadata.");
   }
-  return null;
+  const properties = [
+    ts7.factory.createPropertyAssignment("type", ts7.getMutableClone(decorator.identifier))
+  ];
+  if (decorator.args !== null && decorator.args.length > 0) {
+    const args = decorator.args.map((arg) => {
+      const expr = ts7.getMutableClone(arg);
+      return wrapFunctionsInParens ? wrapFunctionExpressionsInParens(expr) : expr;
+    });
+    properties.push(ts7.factory.createPropertyAssignment("args", ts7.factory.createArrayLiteralExpression(args)));
+  }
+  return ts7.factory.createObjectLiteralExpression(properties, true);
 }
-var parensWrapperTransformerFactory = (context) => {
-  const visitor = (node) => {
-    const visited = ts3.visitEachChild(node, visitor, context);
-    if (ts3.isArrowFunction(visited) || ts3.isFunctionExpression(visited)) {
-      return ts3.createParen(visited);
-    }
-    return visited;
-  };
-  return (node) => ts3.visitEachChild(node, visitor, context);
-};
-function wrapFunctionExpressionsInParens(expression) {
-  return ts3.transform(expression, [parensWrapperTransformerFactory]).transformed[0];
+function isAngularDecorator2(decorator, isCore) {
+  return isCore || decorator.import !== null && decorator.import.from === "@angular/core";
 }
-function makeDuplicateDeclarationError(node, data, kind) {
-  const context = [];
-  for (const decl of data) {
-    if (decl.rawDeclarations === null) {
-      continue;
-    }
-    const contextNode = decl.ref.getOriginForDiagnostics(decl.rawDeclarations, decl.ngModule.name);
-    context.push(makeRelatedInformation(contextNode, `'${node.name.text}' is listed in the declarations of the NgModule '${decl.ngModule.name.text}'.`));
-  }
-  return makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_NOT_UNIQUE, node.name, `The ${kind} '${node.name.text}' is declared by more than one NgModule.`, context);
+function removeIdentifierReferences(node, name) {
+  const result = ts7.transform(node, [(context) => (root) => ts7.visitNode(root, function walk(current) {
+    return ts7.isIdentifier(current) && current.text === name ? ts7.factory.createIdentifier(current.text) : ts7.visitEachChild(current, walk, context);
+  })]);
+  return result.transformed[0];
 }
-function resolveProvidersRequiringFactory(rawProviders, reflector, evaluator) {
-  const providers = /* @__PURE__ */ new Set();
-  const resolvedProviders = evaluator.evaluate(rawProviders);
-  if (!Array.isArray(resolvedProviders)) {
-    return providers;
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/references_registry.mjs
+var NoopReferencesRegistry = class {
+  add(source, ...references) {
   }
-  resolvedProviders.forEach(function processProviders(provider) {
-    let tokenClass = null;
-    if (Array.isArray(provider)) {
-      provider.forEach(processProviders);
-    } else if (provider instanceof Reference) {
-      tokenClass = provider;
-    } else if (provider instanceof Map && provider.has("useClass") && !provider.has("deps")) {
-      const useExisting = provider.get("useClass");
-      if (useExisting instanceof Reference) {
-        tokenClass = useExisting;
-      }
-    }
-    if (tokenClass !== null && !tokenClass.node.getSourceFile().isDeclarationFile && reflector.isClass(tokenClass.node)) {
-      const constructorParameters = reflector.getConstructorParameters(tokenClass.node);
-      if (constructorParameters !== null && constructorParameters.length > 0) {
-        providers.add(tokenClass);
-      }
-    }
-  });
-  return providers;
-}
-function wrapTypeReference(reflector, clazz) {
-  const dtsClass = reflector.getDtsDeclaration(clazz);
-  const value = new WrappedNodeExpr(clazz.name);
-  const type = dtsClass !== null && isNamedClassDeclaration(dtsClass) ? new WrappedNodeExpr(dtsClass.name) : value;
-  return { value, type };
-}
-function createSourceSpan(node) {
-  const sf = node.getSourceFile();
-  const [startOffset, endOffset] = [node.getStart(), node.getEnd()];
-  const { line: startLine, character: startCol } = sf.getLineAndCharacterOfPosition(startOffset);
-  const { line: endLine, character: endCol } = sf.getLineAndCharacterOfPosition(endOffset);
-  const parseSf = new ParseSourceFile(sf.getFullText(), sf.fileName);
-  return new ParseSourceSpan(new ParseLocation(parseSf, startOffset, startLine + 1, startCol + 1), new ParseLocation(parseSf, endOffset, endLine + 1, endCol + 1));
-}
-function compileResults(fac, def, metadataStmt, propName) {
-  const statements = def.statements;
-  if (metadataStmt !== null) {
-    statements.push(metadataStmt);
-  }
-  return [
-    fac,
-    {
-      name: propName,
-      initializer: def.expression,
-      statements: def.statements,
-      type: def.type
-    }
-  ];
-}
-function toFactoryMetadata(meta, target) {
-  return {
-    name: meta.name,
-    type: meta.type,
-    internalType: meta.internalType,
-    typeArgumentCount: meta.typeArgumentCount,
-    deps: meta.deps,
-    target
-  };
-}
+};
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/component.mjs
-import { compileClassMetadata as compileClassMetadata3, compileComponentFromMetadata, compileDeclareClassMetadata as compileDeclareClassMetadata3, compileDeclareComponentFromMetadata, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DomElementSchemaRegistry, ExternalExpr as ExternalExpr5, FactoryTarget as FactoryTarget3, InterpolationConfig, makeBindingParser as makeBindingParser2, ParseSourceFile as ParseSourceFile2, parseTemplate, R3TargetBinder, SelectorMatcher, ViewEncapsulation, WrappedNodeExpr as WrappedNodeExpr5 } from "@angular/compiler";
-import ts21 from "typescript";
+// 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, DEFAULT_INTERPOLATION_CONFIG as DEFAULT_INTERPOLATION_CONFIG2, DomElementSchemaRegistry, FactoryTarget as FactoryTarget3, makeBindingParser as makeBindingParser2, R3TargetBinder, SelectorMatcher, ViewEncapsulation, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
+import ts25 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.mjs
-import ts4 from "typescript";
+import ts8 from "typescript";
 var SemanticSymbol = class {
   constructor(decl) {
     this.decl = decl;
@@ -1429,7 +1677,7 @@ var SemanticSymbol = class {
   }
 };
 function getSymbolIdentifier(decl) {
-  if (!ts4.isSourceFile(decl.parent)) {
+  if (!ts8.isSourceFile(decl.parent)) {
     return null;
   }
   return decl.name.text;
@@ -1579,7 +1827,7 @@ function getImportPath(expr) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters.mjs
-import ts5 from "typescript";
+import ts9 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util.mjs
 function isSymbolEqual(a, b) {
@@ -1633,7 +1881,7 @@ function isSetEqual(a, b, equalityTester = referenceEquality) {
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters.mjs
 function extractSemanticTypeParameters(node) {
-  if (!ts5.isClassDeclaration(node) || node.typeParameters === void 0) {
+  if (!ts9.isClassDeclaration(node) || node.typeParameters === void 0) {
     return null;
   }
   return node.typeParameters.map((typeParam) => ({ hasGenericTypeBound: typeParam.constraint !== void 0 }));
@@ -1659,7 +1907,7 @@ var MetaType;
 })(MetaType || (MetaType = {}));
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/dts.mjs
-import ts7 from "typescript";
+import ts11 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/property_mapping.mjs
 var ClassPropertyMapping = class {
@@ -1738,13 +1986,13 @@ function reverseMapFromForwardMap(forwardMap) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/util.mjs
-import ts6 from "typescript";
+import ts10 from "typescript";
 function extractReferencesFromType(checker, def, bestGuessOwningModule) {
-  if (!ts6.isTupleTypeNode(def)) {
+  if (!ts10.isTupleTypeNode(def)) {
     return [];
   }
   return def.elements.map((element) => {
-    if (!ts6.isTypeQueryNode(element)) {
+    if (!ts10.isTypeQueryNode(element)) {
       throw new Error(`Expected TypeQueryNode: ${nodeDebugInfo(element)}`);
     }
     const type = element.exprName;
@@ -1760,18 +2008,18 @@ function extractReferencesFromType(checker, def, bestGuessOwningModule) {
   });
 }
 function readStringType(type) {
-  if (!ts6.isLiteralTypeNode(type) || !ts6.isStringLiteral(type.literal)) {
+  if (!ts10.isLiteralTypeNode(type) || !ts10.isStringLiteral(type.literal)) {
     return null;
   }
   return type.literal.text;
 }
 function readStringMapType(type) {
-  if (!ts6.isTypeLiteralNode(type)) {
+  if (!ts10.isTypeLiteralNode(type)) {
     return {};
   }
   const obj = {};
   type.members.forEach((member) => {
-    if (!ts6.isPropertySignature(member) || member.type === void 0 || member.name === void 0 || !ts6.isStringLiteral(member.name)) {
+    if (!ts10.isPropertySignature(member) || member.type === void 0 || member.name === void 0 || !ts10.isStringLiteral(member.name)) {
       return;
     }
     const value = readStringType(member.type);
@@ -1783,12 +2031,12 @@ function readStringMapType(type) {
   return obj;
 }
 function readStringArrayType(type) {
-  if (!ts6.isTupleTypeNode(type)) {
+  if (!ts10.isTupleTypeNode(type)) {
     return [];
   }
   const res = [];
   type.elements.forEach((el) => {
-    if (!ts6.isLiteralTypeNode(el) || !ts6.isStringLiteral(el.literal)) {
+    if (!ts10.isLiteralTypeNode(el) || !ts10.isStringLiteral(el.literal)) {
       return;
     }
     res.push(el.literal.text);
@@ -1813,7 +2061,7 @@ function extractDirectiveTypeCheckMeta(node, inputs, reflector) {
     if (isRestricted(field.node)) {
       restrictedInputFields.add(classPropertyName);
     }
-    if (field.nameNode !== null && ts6.isStringLiteral(field.nameNode)) {
+    if (field.nameNode !== null && ts10.isStringLiteral(field.nameNode)) {
       stringLiteralInputFields.add(classPropertyName);
     }
   }
@@ -1832,7 +2080,7 @@ function isRestricted(node) {
   if (node.modifiers === void 0) {
     return false;
   }
-  return node.modifiers.some((modifier) => modifier.kind === ts6.SyntaxKind.PrivateKeyword || modifier.kind === ts6.SyntaxKind.ProtectedKeyword || modifier.kind === ts6.SyntaxKind.ReadonlyKeyword);
+  return node.modifiers.some((modifier) => modifier.kind === ts10.SyntaxKind.PrivateKeyword || modifier.kind === ts10.SyntaxKind.ProtectedKeyword || modifier.kind === ts10.SyntaxKind.ReadonlyKeyword);
 }
 function extractTemplateGuard(member) {
   if (!member.name.startsWith("ngTemplateGuard_")) {
@@ -1841,7 +2089,7 @@ function extractTemplateGuard(member) {
   const inputName = afterUnderscore(member.name);
   if (member.kind === ClassMemberKind.Property) {
     let type = null;
-    if (member.type !== null && ts6.isLiteralTypeNode(member.type) && ts6.isStringLiteral(member.type.literal)) {
+    if (member.type !== null && ts10.isLiteralTypeNode(member.type) && ts10.isStringLiteral(member.type.literal)) {
       type = member.type.literal.text;
     }
     if (type !== "binding") {
@@ -1915,7 +2163,7 @@ var DtsMetadataReader = class {
     const ngModuleDef = this.reflector.getMembersOfClass(clazz).find((member) => member.name === "\u0275mod" && member.isStatic);
     if (ngModuleDef === void 0) {
       return null;
-    } else if (ngModuleDef.type === null || !ts7.isTypeReferenceNode(ngModuleDef.type) || ngModuleDef.type.typeArguments === void 0 || ngModuleDef.type.typeArguments.length !== 4) {
+    } else if (ngModuleDef.type === null || !ts11.isTypeReferenceNode(ngModuleDef.type) || ngModuleDef.type.typeArguments === void 0 || ngModuleDef.type.typeArguments.length !== 4) {
       return null;
     }
     const [_, declarationMetadata, importMetadata, exportMetadata] = ngModuleDef.type.typeArguments;
@@ -1933,7 +2181,7 @@ var DtsMetadataReader = class {
     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 || !ts7.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
+    } else if (def.type === null || !ts11.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
       return null;
     }
     const isComponent = def.name === "\u0275cmp";
@@ -1957,18 +2205,19 @@ var DtsMetadataReader = class {
       baseClass: readBaseClass2(clazz, this.checker, this.reflector),
       isPoisoned: false,
       isStructural,
-      animationTriggerNames: null
+      animationTriggerNames: null,
+      isStandalone: false
     });
   }
   getPipeMetadata(ref) {
     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 || !ts7.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
+    } else if (def.type === null || !ts11.isTypeReferenceNode(def.type) || def.type.typeArguments === void 0 || def.type.typeArguments.length < 2) {
       return null;
     }
     const type = def.type.typeArguments[1];
-    if (!ts7.isLiteralTypeNode(type) || !ts7.isStringLiteral(type.literal)) {
+    if (!ts11.isLiteralTypeNode(type) || !ts11.isStringLiteral(type.literal)) {
       return null;
     }
     const name = type.literal.text;
@@ -1976,7 +2225,8 @@ var DtsMetadataReader = class {
       type: MetaType.Pipe,
       ref,
       name,
-      nameExpr: null
+      nameExpr: null,
+      isStandalone: false
     };
   }
 };
@@ -1986,12 +2236,12 @@ function readBaseClass2(clazz, checker, reflector) {
   }
   if (clazz.heritageClauses !== void 0) {
     for (const clause of clazz.heritageClauses) {
-      if (clause.token === ts7.SyntaxKind.ExtendsKeyword) {
+      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 & ts7.SymbolFlags.Alias) {
+        } else if (symbol.flags & ts11.SymbolFlags.Alias) {
           symbol = checker.getAliasedSymbol(symbol);
         }
         if (symbol.valueDeclaration !== void 0 && isNamedClassDeclaration(symbol.valueDeclaration)) {
@@ -2205,28 +2455,28 @@ var HandlerFlags;
 })(HandlerFlags || (HandlerFlags = {}));
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/alias.mjs
-import ts8 from "typescript";
+import ts12 from "typescript";
 function aliasTransformFactory(exportStatements) {
   return (context) => {
     return (file) => {
-      if (ts8.isBundle(file) || !exportStatements.has(file.fileName)) {
+      if (ts12.isBundle(file) || !exportStatements.has(file.fileName)) {
         return file;
       }
       const statements = [...file.statements];
       exportStatements.get(file.fileName).forEach(([moduleName, symbolName], aliasName) => {
-        const stmt = ts8.createExportDeclaration(void 0, void 0, ts8.createNamedExports([createExportSpecifier(symbolName, aliasName)]), ts8.createStringLiteral(moduleName));
+        const stmt = ts12.factory.createExportDeclaration(void 0, void 0, false, ts12.createNamedExports([createExportSpecifier(symbolName, aliasName)]), ts12.factory.createStringLiteral(moduleName));
         statements.push(stmt);
       });
-      return ts8.updateSourceFileNode(file, statements);
+      return ts12.factory.updateSourceFile(file, statements);
     };
   };
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
-import ts12 from "typescript";
+import ts16 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/adapter.mjs
-import ts9 from "typescript";
+import ts13 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/expando.mjs
 var NgExtension = Symbol("NgExtension");
@@ -2372,7 +2622,7 @@ var ShimAdapter = class {
           return void 0;
         }
       }
-      const inputFile = this.delegate.getSourceFile(baseFileName, ts9.ScriptTarget.Latest);
+      const inputFile = this.delegate.getSourceFile(baseFileName, ts13.ScriptTarget.Latest);
       if (inputFile === void 0 || isShim(inputFile)) {
         return void 0;
       }
@@ -2401,7 +2651,7 @@ var ShimAdapter = class {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/factory_generator.mjs
-import ts10 from "typescript";
+import ts14 from "typescript";
 var TS_DTS_SUFFIX = /(\.d)?\.ts$/;
 var STRIP_NG_FACTORY = /(.*)NgFactory$/;
 var FactoryGenerator = class {
@@ -2414,7 +2664,7 @@ var FactoryGenerator = class {
   generateShimForFile(sf, genFilePath) {
     const absoluteSfPath = absoluteFromSourceFile(sf);
     const relativePathToSource = "./" + basename(sf.fileName).replace(TS_DTS_SUFFIX, "");
-    const symbolNames = sf.statements.filter(ts10.isClassDeclaration).filter((decl) => isExported(decl) && decl.decorators !== void 0 && decl.name !== void 0).map((decl) => decl.name.text);
+    const symbolNames = sf.statements.filter(ts14.isClassDeclaration).filter((decl) => isExported(decl) && decl.decorators !== void 0 && decl.name !== void 0).map((decl) => decl.name.text);
     let sourceText = "";
     const leadingComment = getFileoverviewComment(sf);
     if (leadingComment !== null) {
@@ -2429,7 +2679,7 @@ var FactoryGenerator = class {
       ].join("\n");
     }
     sourceText += "\nexport const \u0275NonEmptyModule = true;";
-    const genFile = ts10.createSourceFile(genFilePath, sourceText, sf.languageVersion, true, ts10.ScriptKind.TS);
+    const genFile = ts14.createSourceFile(genFilePath, sourceText, sf.languageVersion, true, ts14.ScriptKind.TS);
     if (sf.moduleName !== void 0) {
       genFile.moduleName = generatedModuleName(sf.moduleName, sf.fileName, ".ngfactory");
     }
@@ -2448,7 +2698,7 @@ var FactoryGenerator = class {
   }
 };
 function isExported(decl) {
-  return decl.modifiers !== void 0 && decl.modifiers.some((mod) => mod.kind == ts10.SyntaxKind.ExportKeyword);
+  return decl.modifiers !== void 0 && decl.modifiers.some((mod) => mod.kind == ts14.SyntaxKind.ExportKeyword);
 }
 function generatedFactoryTransform(factoryMap, importRewriter) {
   return (context) => {
@@ -2466,19 +2716,19 @@ function transformFactorySourceFile(factoryMap, context, importRewriter, file) {
   let nonEmptyExport = null;
   const coreImportIdentifiers = /* @__PURE__ */ new Set();
   for (const stmt of file.statements) {
-    if (ts10.isImportDeclaration(stmt) && ts10.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === "@angular/core") {
+    if (ts14.isImportDeclaration(stmt) && ts14.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === "@angular/core") {
       const rewrittenModuleSpecifier = importRewriter.rewriteSpecifier("@angular/core", sourceFilePath);
       if (rewrittenModuleSpecifier !== stmt.moduleSpecifier.text) {
-        transformedStatements.push(ts10.updateImportDeclaration(stmt, stmt.decorators, stmt.modifiers, stmt.importClause, ts10.createStringLiteral(rewrittenModuleSpecifier), void 0));
-        if (stmt.importClause !== void 0 && stmt.importClause.namedBindings !== void 0 && ts10.isNamespaceImport(stmt.importClause.namedBindings)) {
+        transformedStatements.push(ts14.factory.updateImportDeclaration(stmt, stmt.decorators, stmt.modifiers, stmt.importClause, ts14.factory.createStringLiteral(rewrittenModuleSpecifier), void 0));
+        if (stmt.importClause !== void 0 && stmt.importClause.namedBindings !== void 0 && ts14.isNamespaceImport(stmt.importClause.namedBindings)) {
           coreImportIdentifiers.add(stmt.importClause.namedBindings.name.text);
         }
       } else {
         transformedStatements.push(stmt);
       }
-    } else if (ts10.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {
+    } else if (ts14.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {
       const decl = stmt.declarationList.declarations[0];
-      if (ts10.isIdentifier(decl.name)) {
+      if (ts14.isIdentifier(decl.name)) {
         if (decl.name.text === "\u0275NonEmptyModule") {
           nonEmptyExport = stmt;
           continue;
@@ -2497,17 +2747,17 @@ function transformFactorySourceFile(factoryMap, context, importRewriter, file) {
       transformedStatements.push(stmt);
     }
   }
-  if (!transformedStatements.some(ts10.isVariableStatement) && nonEmptyExport !== null) {
+  if (!transformedStatements.some(ts14.isVariableStatement) && nonEmptyExport !== null) {
     transformedStatements.push(nonEmptyExport);
   }
-  file = ts10.updateSourceFileNode(file, transformedStatements);
+  file = ts14.factory.updateSourceFile(file, transformedStatements);
   if (coreImportIdentifiers.size > 0) {
     const visit2 = (node) => {
-      node = ts10.visitEachChild(node, (child) => visit2(child), context);
-      if (ts10.isPropertyAccessExpression(node) && ts10.isIdentifier(node.expression) && coreImportIdentifiers.has(node.expression.text)) {
+      node = ts14.visitEachChild(node, (child) => visit2(child), context);
+      if (ts14.isPropertyAccessExpression(node) && ts14.isIdentifier(node.expression) && coreImportIdentifiers.has(node.expression.text)) {
         const rewrittenSymbol = importRewriter.rewriteSymbol(node.name.text, "@angular/core");
         if (rewrittenSymbol !== node.name.text) {
-          const updated = ts10.updatePropertyAccess(node, node.expression, ts10.createIdentifier(rewrittenSymbol));
+          const updated = ts14.factory.updatePropertyAccessExpression(node, node.expression, ts14.factory.createIdentifier(rewrittenSymbol));
           node = updated;
         }
       }
@@ -2520,12 +2770,12 @@ function transformFactorySourceFile(factoryMap, context, importRewriter, file) {
 function getFileoverviewComment(sourceFile) {
   const text = sourceFile.getFullText();
   const trivia = text.substring(0, sourceFile.getStart());
-  const leadingComments = ts10.getLeadingCommentRanges(trivia, 0);
+  const leadingComments = ts14.getLeadingCommentRanges(trivia, 0);
   if (!leadingComments || leadingComments.length === 0) {
     return null;
   }
   const comment = leadingComments[0];
-  if (comment.kind !== ts10.SyntaxKind.MultiLineCommentTrivia) {
+  if (comment.kind !== ts14.SyntaxKind.MultiLineCommentTrivia) {
     return null;
   }
   if (text.substring(comment.end, comment.end + 2) !== "\n\n") {
@@ -2538,15 +2788,15 @@ function getFileoverviewComment(sourceFile) {
   return commentText;
 }
 function wrapInNoSideEffects(expr) {
-  const noSideEffects = ts10.createPropertyAccess(ts10.createIdentifier("i0"), "\u0275noSideEffects");
-  return ts10.createCall(noSideEffects, [], [
-    ts10.createFunctionExpression([], void 0, void 0, [], [], void 0, ts10.createBlock([
-      ts10.createReturn(expr)
+  const noSideEffects = ts14.factory.createPropertyAccessExpression(ts14.factory.createIdentifier("i0"), "\u0275noSideEffects");
+  return ts14.factory.createCallExpression(noSideEffects, [], [
+    ts14.factory.createFunctionExpression([], void 0, void 0, [], [], void 0, ts14.factory.createBlock([
+      ts14.factory.createReturnStatement(expr)
     ]))
   ]);
 }
 function updateInitializers(stmt, update) {
-  return ts10.updateVariableStatement(stmt, stmt.modifiers, ts10.updateVariableDeclarationList(stmt.declarationList, stmt.declarationList.declarations.map((decl) => ts10.updateVariableDeclaration(decl, decl.name, decl.type, update(decl.initializer)))));
+  return ts14.factory.updateVariableStatement(stmt, stmt.modifiers, ts14.factory.updateVariableDeclarationList(stmt.declarationList, stmt.declarationList.declarations.map((decl) => ts14.updateVariableDeclaration(decl, decl.name, decl.type, update(decl.initializer)))));
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/reference_tagger.mjs
@@ -2584,7 +2834,7 @@ var ShimReferenceTagger = class {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/summary_generator.mjs
-import ts11 from "typescript";
+import ts15 from "typescript";
 var SummaryGenerator = class {
   constructor() {
     this.shouldEmit = true;
@@ -2593,13 +2843,13 @@ var SummaryGenerator = class {
   generateShimForFile(sf, genFilePath) {
     const symbolNames = [];
     for (const stmt of sf.statements) {
-      if (ts11.isClassDeclaration(stmt)) {
+      if (ts15.isClassDeclaration(stmt)) {
         if (!isExported2(stmt) || stmt.decorators === void 0 || stmt.name === void 0) {
           continue;
         }
         symbolNames.push(stmt.name.text);
-      } else if (ts11.isExportDeclaration(stmt)) {
-        if (stmt.exportClause === void 0 || stmt.moduleSpecifier !== void 0 || !ts11.isNamedExports(stmt.exportClause)) {
+      } else if (ts15.isExportDeclaration(stmt)) {
+        if (stmt.exportClause === void 0 || stmt.moduleSpecifier !== void 0 || !ts15.isNamedExports(stmt.exportClause)) {
           continue;
         }
         for (const specifier of stmt.exportClause.elements) {
@@ -2612,7 +2862,7 @@ var SummaryGenerator = class {
       varLines.push(`export const \u0275empty = null;`);
     }
     const sourceText = varLines.join("\n");
-    const genFile = ts11.createSourceFile(genFilePath, sourceText, sf.languageVersion, true, ts11.ScriptKind.TS);
+    const genFile = ts15.createSourceFile(genFilePath, sourceText, sf.languageVersion, true, ts15.ScriptKind.TS);
     if (sf.moduleName !== void 0) {
       genFile.moduleName = generatedModuleName(sf.moduleName, sf.fileName, ".ngsummary");
     }
@@ -2620,7 +2870,7 @@ var SummaryGenerator = class {
   }
 };
 function isExported2(decl) {
-  return decl.modifiers !== void 0 && decl.modifiers.some((mod) => mod.kind == ts11.SyntaxKind.ExportKeyword);
+  return decl.modifiers !== void 0 && decl.modifiers.some((mod) => mod.kind == ts15.SyntaxKind.ExportKeyword);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/trait.mjs
@@ -2726,7 +2976,7 @@ var TraitCompiler = class {
       if (this.reflector.isClass(node)) {
         this.analyzeClass(node, preanalyze ? promises : null);
       }
-      ts12.forEachChild(node, visit2);
+      ts16.forEachChild(node, visit2);
     };
     visit2(sf);
     if (!this.fileToClasses.has(sf)) {
@@ -2840,7 +3090,7 @@ var TraitCompiler = class {
         }
         if (isPrimaryHandler && record.hasPrimaryHandler) {
           record.metaDiagnostics = [{
-            category: ts12.DiagnosticCategory.Error,
+            category: ts16.DiagnosticCategory.Error,
             code: Number("-99" + ErrorCode.DECORATOR_COLLISION),
             file: getSourceFile(clazz),
             start: clazz.getStart(void 0, false),
@@ -3048,7 +3298,7 @@ var TraitCompiler = class {
     }
   }
   compile(clazz, constantPool) {
-    const original = ts12.getOriginalNode(clazz);
+    const original = ts16.getOriginalNode(clazz);
     if (!this.reflector.isClass(clazz) || !this.reflector.isClass(original) || !this.classes.has(original)) {
       return null;
     }
@@ -3079,7 +3329,7 @@ var TraitCompiler = class {
     return res.length > 0 ? res : null;
   }
   decoratorsFor(node) {
-    const original = ts12.getOriginalNode(node);
+    const original = ts16.getOriginalNode(node);
     if (!this.reflector.isClass(original) || !this.classes.has(original)) {
       return [];
     }
@@ -3089,7 +3339,7 @@ var TraitCompiler = class {
       if (trait.state !== TraitState.Resolved) {
         continue;
       }
-      if (trait.detected.trigger !== null && ts12.isDecorator(trait.detected.trigger)) {
+      if (trait.detected.trigger !== null && ts16.isDecorator(trait.detected.trigger)) {
         decorators.push(trait.detected.trigger);
       }
     }
@@ -3119,23 +3369,23 @@ var TraitCompiler = class {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
-import ts14 from "typescript";
+import ts18 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/utils.mjs
-import ts13 from "typescript";
+import ts17 from "typescript";
 function addImports(importManager, sf, extraStatements = []) {
   const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
-    const qualifier = ts13.createIdentifier(i.qualifier.text);
-    const importClause = ts13.createImportClause(void 0, ts13.createNamespaceImport(qualifier));
-    const decl = ts13.createImportDeclaration(void 0, void 0, importClause, ts13.createLiteral(i.specifier));
-    ts13.setOriginalNode(i.qualifier, decl);
+    const qualifier = ts17.factory.createIdentifier(i.qualifier.text);
+    const importClause = ts17.factory.createImportClause(false, void 0, ts17.factory.createNamespaceImport(qualifier));
+    const decl = ts17.factory.createImportDeclaration(void 0, void 0, importClause, ts17.factory.createStringLiteral(i.specifier));
+    ts17.setOriginalNode(i.qualifier, decl);
     return decl;
   });
   const existingImports = sf.statements.filter((stmt) => isImportStatement(stmt));
   const body = sf.statements.filter((stmt) => !isImportStatement(stmt));
   if (addedImports.length > 0) {
-    const fileoverviewAnchorStmt = ts13.createNotEmittedStatement(sf);
-    return ts13.updateSourceFileNode(sf, ts13.createNodeArray([
+    const fileoverviewAnchorStmt = ts17.factory.createNotEmittedStatement(sf);
+    return ts17.factory.updateSourceFile(sf, ts17.factory.createNodeArray([
       fileoverviewAnchorStmt,
       ...existingImports,
       ...addedImports,
@@ -3146,7 +3396,7 @@ function addImports(importManager, sf, extraStatements = []) {
   return sf;
 }
 function isImportStatement(stmt) {
-  return ts13.isImportDeclaration(stmt) || ts13.isImportEqualsDeclaration(stmt) || ts13.isNamespaceImport(stmt);
+  return ts17.isImportDeclaration(stmt) || ts17.isImportEqualsDeclaration(stmt) || ts17.isNamespaceImport(stmt);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
@@ -3164,7 +3414,7 @@ var DtsTransformRegistry = class {
     if (!sf.isDeclarationFile) {
       return null;
     }
-    const originalSf = ts14.getOriginalNode(sf);
+    const originalSf = ts18.getOriginalNode(sf);
     let transforms = null;
     if (this.ivyDeclarationTransforms.has(originalSf)) {
       transforms = [];
@@ -3177,7 +3427,7 @@ function declarationTransformFactory(transformRegistry, importRewriter, importPr
   return (context) => {
     const transformer = new DtsTransformer(context, importRewriter, importPrefix);
     return (fileOrBundle) => {
-      if (ts14.isBundle(fileOrBundle)) {
+      if (ts18.isBundle(fileOrBundle)) {
         return fileOrBundle;
       }
       const transforms = transformRegistry.getAllTransforms(fileOrBundle);
@@ -3197,15 +3447,15 @@ var DtsTransformer = class {
   transform(sf, transforms) {
     const imports = new ImportManager(this.importRewriter, this.importPrefix);
     const visitor = (node) => {
-      if (ts14.isClassDeclaration(node)) {
+      if (ts18.isClassDeclaration(node)) {
         return this.transformClassDeclaration(node, transforms, imports);
-      } else if (ts14.isFunctionDeclaration(node)) {
+      } else if (ts18.isFunctionDeclaration(node)) {
         return this.transformFunctionDeclaration(node, transforms, imports);
       } else {
-        return ts14.visitEachChild(node, visitor, this.ctx);
+        return ts18.visitEachChild(node, visitor, this.ctx);
       }
     };
-    sf = ts14.visitNode(sf, visitor);
+    sf = ts18.visitNode(sf, visitor);
     return addImports(imports, sf);
   }
   transformClassDeclaration(clazz, transforms, imports) {
@@ -3233,7 +3483,7 @@ var DtsTransformer = class {
       }
     }
     if (elementsChanged && clazz === newClazz) {
-      newClazz = ts14.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, elements);
+      newClazz = ts18.factory.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, elements);
     }
     return newClazz;
   }
@@ -3255,31 +3505,31 @@ var IvyDeclarationDtsTransform = class {
     this.declarationFields.set(decl, fields);
   }
   transformClass(clazz, members, imports) {
-    const original = ts14.getOriginalNode(clazz);
+    const original = ts18.getOriginalNode(clazz);
     if (!this.declarationFields.has(original)) {
       return clazz;
     }
     const fields = this.declarationFields.get(original);
     const newMembers = fields.map((decl) => {
-      const modifiers = [ts14.createModifier(ts14.SyntaxKind.StaticKeyword)];
+      const modifiers = [ts18.factory.createModifier(ts18.SyntaxKind.StaticKeyword)];
       const typeRef = translateType(decl.type, imports);
       markForEmitAsSingleLine(typeRef);
-      return ts14.createProperty(void 0, modifiers, decl.name, void 0, typeRef, void 0);
+      return ts18.factory.createPropertyDeclaration(void 0, modifiers, decl.name, void 0, typeRef, void 0);
     });
-    return ts14.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, [...members, ...newMembers]);
+    return ts18.factory.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, [...members, ...newMembers]);
   }
 };
 function markForEmitAsSingleLine(node) {
-  ts14.setEmitFlags(node, ts14.EmitFlags.SingleLine);
-  ts14.forEachChild(node, markForEmitAsSingleLine);
+  ts18.setEmitFlags(node, ts18.EmitFlags.SingleLine);
+  ts18.forEachChild(node, markForEmitAsSingleLine);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
 import { ConstantPool } from "@angular/compiler";
-import ts16 from "typescript";
+import ts20 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/visitor.mjs
-import ts15 from "typescript";
+import ts19 from "typescript";
 function visit(node, visitor, context) {
   return visitor._visit(node, context);
 }
@@ -3303,8 +3553,8 @@ var Visitor = class {
   }
   _visit(node, context) {
     let visitedNode = null;
-    node = ts15.visitEachChild(node, (child) => this._visit(child, context), context);
-    if (ts15.isClassDeclaration(node)) {
+    node = ts19.visitEachChild(node, (child) => this._visit(child, context), context);
+    if (ts19.isClassDeclaration(node)) {
       visitedNode = this._visitListEntryNode(node, (node2) => this.visitClassDeclaration(node2));
     } else {
       visitedNode = this.visitOtherNode(node);
@@ -3318,7 +3568,7 @@ var Visitor = class {
     if (node.statements.every((stmt) => !this._before.has(stmt) && !this._after.has(stmt))) {
       return node;
     }
-    const clone = ts15.getMutableClone(node);
+    const clone = ts19.getMutableClone(node);
     const newStatements = [];
     clone.statements.forEach((stmt) => {
       if (this._before.has(stmt)) {
@@ -3331,7 +3581,7 @@ var Visitor = class {
         this._after.delete(stmt);
       }
     });
-    clone.statements = ts15.createNodeArray(newStatements, node.statements.hasTrailingComma);
+    clone.statements = ts19.factory.createNodeArray(newStatements, node.statements.hasTrailingComma);
     return clone;
   }
 };
@@ -3372,568 +3622,168 @@ var IvyTransformationVisitor = class extends Visitor {
     this.compilation = compilation;
     this.classCompilationMap = classCompilationMap;
     this.reflector = reflector;
-    this.importManager = importManager;
-    this.recordWrappedNodeExpr = recordWrappedNodeExpr;
-    this.isClosureCompilerEnabled = isClosureCompilerEnabled;
-    this.isCore = isCore;
-  }
-  visitClassDeclaration(node) {
-    if (!this.classCompilationMap.has(node)) {
-      return { node };
-    }
-    const translateOptions = {
-      recordWrappedNode: this.recordWrappedNodeExpr,
-      annotateForClosureCompiler: this.isClosureCompilerEnabled
-    };
-    const statements = [];
-    const members = [...node.members];
-    for (const field of this.classCompilationMap.get(node)) {
-      const exprNode = translateExpression(field.initializer, this.importManager, translateOptions);
-      const property = ts16.createProperty(void 0, [ts16.createToken(ts16.SyntaxKind.StaticKeyword)], field.name, void 0, void 0, exprNode);
-      if (this.isClosureCompilerEnabled) {
-        ts16.addSyntheticLeadingComment(property, ts16.SyntaxKind.MultiLineCommentTrivia, "* @nocollapse ", false);
-      }
-      field.statements.map((stmt) => translateStatement(stmt, this.importManager, translateOptions)).forEach((stmt) => statements.push(stmt));
-      members.push(property);
-    }
-    node = ts16.updateClassDeclaration(node, maybeFilterDecorator(node.decorators, this.compilation.decoratorsFor(node)), node.modifiers, node.name, node.typeParameters, node.heritageClauses || [], members.map((member) => this._stripAngularDecorators(member)));
-    return { node, after: statements };
-  }
-  _angularCoreDecorators(decl) {
-    const decorators = this.reflector.getDecoratorsOfDeclaration(decl);
-    if (decorators === null) {
-      return NO_DECORATORS;
-    }
-    const coreDecorators = decorators.filter((dec) => this.isCore || isFromAngularCore(dec)).map((dec) => dec.node);
-    if (coreDecorators.length > 0) {
-      return new Set(coreDecorators);
-    } else {
-      return NO_DECORATORS;
-    }
-  }
-  _nonCoreDecoratorsOnly(node) {
-    if (node.decorators === void 0) {
-      return void 0;
-    }
-    const coreDecorators = this._angularCoreDecorators(node);
-    if (coreDecorators.size === node.decorators.length) {
-      return void 0;
-    } else if (coreDecorators.size === 0) {
-      return node.decorators;
-    }
-    const filtered = node.decorators.filter((dec) => !coreDecorators.has(dec));
-    if (filtered.length === 0) {
-      return void 0;
-    }
-    const array = ts16.createNodeArray(filtered);
-    array.pos = node.decorators.pos;
-    array.end = node.decorators.end;
-    return array;
-  }
-  _stripAngularDecorators(node) {
-    if (ts16.isParameter(node)) {
-      node = ts16.updateParameter(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
-    } else if (ts16.isMethodDeclaration(node) && node.decorators !== void 0) {
-      node = ts16.updateMethod(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
-    } else if (ts16.isPropertyDeclaration(node) && node.decorators !== void 0) {
-      node = ts16.updateProperty(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.questionToken, node.type, node.initializer);
-    } else if (ts16.isGetAccessor(node)) {
-      node = ts16.updateGetAccessor(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.parameters, node.type, node.body);
-    } else if (ts16.isSetAccessor(node)) {
-      node = ts16.updateSetAccessor(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.parameters, node.body);
-    } else if (ts16.isConstructorDeclaration(node)) {
-      const parameters = node.parameters.map((param) => this._stripAngularDecorators(param));
-      node = ts16.updateConstructor(node, node.decorators, node.modifiers, parameters, node.body);
-    }
-    return node;
-  }
-};
-function transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNode) {
-  const constantPool = new ConstantPool(isClosureCompilerEnabled);
-  const importManager = new ImportManager(importRewriter);
-  const compilationVisitor = new IvyCompilationVisitor(compilation, constantPool);
-  visit(file, compilationVisitor, context);
-  const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore);
-  let sf = visit(file, transformationVisitor, context);
-  const downlevelTranslatedCode = getLocalizeCompileTarget(context) < ts16.ScriptTarget.ES2015;
-  const constants = constantPool.statements.map((stmt) => translateStatement(stmt, importManager, {
-    recordWrappedNode,
-    downlevelTaggedTemplates: downlevelTranslatedCode,
-    downlevelVariableDeclarations: downlevelTranslatedCode,
-    annotateForClosureCompiler: isClosureCompilerEnabled
-  }));
-  const fileOverviewMeta = isClosureCompilerEnabled ? getFileOverviewComment(sf.statements) : null;
-  sf = addImports(importManager, sf, constants);
-  if (fileOverviewMeta !== null) {
-    setFileOverviewComment(sf, fileOverviewMeta);
-  }
-  return sf;
-}
-function getLocalizeCompileTarget(context) {
-  const target = context.getCompilerOptions().target || ts16.ScriptTarget.ES2015;
-  return target !== ts16.ScriptTarget.JSON ? target : ts16.ScriptTarget.ES2015;
-}
-function getFileOverviewComment(statements) {
-  if (statements.length > 0) {
-    const host = statements[0];
-    let trailing = false;
-    let comments = ts16.getSyntheticLeadingComments(host);
-    if (!comments || comments.length === 0) {
-      trailing = true;
-      comments = ts16.getSyntheticTrailingComments(host);
-    }
-    if (comments && comments.length > 0 && CLOSURE_FILE_OVERVIEW_REGEXP.test(comments[0].text)) {
-      return { comments, host, trailing };
-    }
-  }
-  return null;
-}
-function setFileOverviewComment(sf, fileoverview) {
-  const { comments, host, trailing } = fileoverview;
-  if (sf.statements.length > 0 && host !== sf.statements[0]) {
-    if (trailing) {
-      ts16.setSyntheticTrailingComments(host, void 0);
-    } else {
-      ts16.setSyntheticLeadingComments(host, void 0);
-    }
-    ts16.setSyntheticLeadingComments(sf.statements[0], comments);
-  }
-}
-function maybeFilterDecorator(decorators, toRemove) {
-  if (decorators === void 0) {
-    return void 0;
-  }
-  const filtered = decorators.filter((dec) => toRemove.find((decToRemove) => ts16.getOriginalNode(dec) === decToRemove) === void 0);
-  if (filtered.length === 0) {
-    return void 0;
-  }
-  return ts16.createNodeArray(filtered);
-}
-function isFromAngularCore(decorator) {
-  return decorator.import !== null && decorator.import.from === "@angular/core";
-}
-function createRecorderFn(defaultImportTracker) {
-  return (node) => {
-    const importDecl = getDefaultImportDeclaration(node);
-    if (importDecl !== null) {
-      defaultImportTracker.recordUsedImport(importDecl);
-    }
-  };
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/diagnostics.mjs
-import ts17 from "typescript";
-function createValueHasWrongTypeError(node, value, messageText) {
-  var _a;
-  let chainedMessage;
-  let relatedInformation;
-  if (value instanceof DynamicValue) {
-    chainedMessage = "Value could not be determined statically.";
-    relatedInformation = traceDynamicValue(node, value);
-  } else if (value instanceof Reference) {
-    const target = value.debugName !== null ? `'${value.debugName}'` : "an anonymous declaration";
-    chainedMessage = `Value is a reference to ${target}.`;
-    const referenceNode = (_a = identifierOfNode(value.node)) != null ? _a : value.node;
-    relatedInformation = [makeRelatedInformation(referenceNode, "Reference is declared here.")];
-  } else {
-    chainedMessage = `Value is of type '${describeResolvedType(value)}'.`;
-  }
-  const chain = {
-    messageText,
-    category: ts17.DiagnosticCategory.Error,
-    code: 0,
-    next: [{
-      messageText: chainedMessage,
-      category: ts17.DiagnosticCategory.Message,
-      code: 0
-    }]
-  };
-  return new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, node, chain, relatedInformation);
-}
-function getProviderDiagnostics(providerClasses, providersDeclaration, registry) {
-  const diagnostics = [];
-  for (const provider of providerClasses) {
-    if (registry.isInjectable(provider.node)) {
-      continue;
-    }
-    const contextNode = provider.getOriginForDiagnostics(providersDeclaration);
-    diagnostics.push(makeDiagnostic(ErrorCode.UNDECORATED_PROVIDER, contextNode, `The class '${provider.node.name.text}' cannot be created via dependency injection, as it does not have an Angular decorator. This will result in an error at runtime.
-
-Either add the @Injectable() decorator to '${provider.node.name.text}', or configure a different provider (such as a provider with 'useFactory').
-`, [makeRelatedInformation(provider.node, `'${provider.node.name.text}' is declared here.`)]));
-  }
-  return diagnostics;
-}
-function getDirectiveDiagnostics(node, reader, evaluator, reflector, scopeRegistry, kind) {
-  let diagnostics = [];
-  const addDiagnostics = (more) => {
-    if (more === null) {
-      return;
-    } else if (diagnostics === null) {
-      diagnostics = Array.isArray(more) ? more : [more];
-    } else if (Array.isArray(more)) {
-      diagnostics.push(...more);
-    } else {
-      diagnostics.push(more);
-    }
-  };
-  const duplicateDeclarations = scopeRegistry.getDuplicateDeclarations(node);
-  if (duplicateDeclarations !== null) {
-    addDiagnostics(makeDuplicateDeclarationError(node, duplicateDeclarations, kind));
-  }
-  addDiagnostics(checkInheritanceOfDirective(node, reader, reflector, evaluator));
-  return diagnostics;
-}
-function getUndecoratedClassWithAngularFeaturesDiagnostic(node) {
-  return makeDiagnostic(ErrorCode.UNDECORATED_CLASS_USING_ANGULAR_FEATURES, node.name, `Class is using Angular features but is not decorated. Please add an explicit Angular decorator.`);
-}
-function checkInheritanceOfDirective(node, reader, reflector, evaluator) {
-  if (!reflector.isClass(node) || reflector.getConstructorParameters(node) !== null) {
-    return null;
-  }
-  let baseClass = readBaseClass(node, reflector, evaluator);
-  while (baseClass !== null) {
-    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;
-    }
-    baseClass = newParentClass;
-  }
-  return null;
-}
-function getInheritedUndecoratedCtorDiagnostic(node, baseClass, reader) {
-  const subclassMeta = reader.getDirectiveMetadata(new Reference(node));
-  const dirOrComp = subclassMeta.isComponent ? "Component" : "Directive";
-  const baseClassName = baseClass.debugName;
-  return makeDiagnostic(ErrorCode.DIRECTIVE_INHERITS_UNDECORATED_CTOR, node.name, `The ${dirOrComp.toLowerCase()} ${node.name.text} inherits its constructor from ${baseClassName}, but the latter does not have an Angular decorator of its own. Dependency injection will not be able to resolve the parameters of ${baseClassName}'s constructor. Either add a @Directive decorator to ${baseClassName}, or add an explicit constructor to ${node.name.text}.`);
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/directive.mjs
-import { compileClassMetadata, compileDeclareClassMetadata, compileDeclareDirectiveFromMetadata, compileDirectiveFromMetadata, createMayBeForwardRefExpression, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr3, FactoryTarget, getSafePropertyAccessString, makeBindingParser, parseHostBindings, verifyHostBindings, WrappedNodeExpr as WrappedNodeExpr3 } from "@angular/compiler";
-import ts19 from "typescript";
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/factory.mjs
-import { compileDeclareFactoryFunction, compileFactoryFunction } from "@angular/compiler";
-function compileNgFactoryDefField(metadata) {
-  const res = compileFactoryFunction(metadata);
-  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
-}
-function compileDeclareFactory(metadata) {
-  const res = compileDeclareFactoryFunction(metadata);
-  return { name: "\u0275fac", initializer: res.expression, statements: res.statements, type: res.type };
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/metadata.mjs
-import { FunctionExpr, LiteralArrayExpr, LiteralExpr as LiteralExpr2, literalMap, ReturnStatement, WrappedNodeExpr as WrappedNodeExpr2 } from "@angular/compiler";
-import ts18 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 WrappedNodeExpr2(ts18.createArrayLiteral(ngClassDecorators));
-  let metaCtorParameters = null;
-  const classCtorParameters = reflection.getConstructorParameters(clazz);
-  if (classCtorParameters !== null) {
-    const ctorParameters = classCtorParameters.map((param) => ctorParameterToMetadata(param, isCore));
-    metaCtorParameters = new FunctionExpr([], [
-      new ReturnStatement(new LiteralArrayExpr(ctorParameters))
-    ]);
-  }
-  let metaPropDecorators = null;
-  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && member.decorators !== null && member.decorators.length > 0);
-  const duplicateDecoratedMemberNames = classMembers.map((member) => member.name).filter((name, i, arr) => arr.indexOf(name) < i);
-  if (duplicateDecoratedMemberNames.length > 0) {
-    throw new Error(`Duplicate decorated properties found on class '${clazz.name.text}': ` + duplicateDecoratedMemberNames.join(", "));
-  }
-  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 WrappedNodeExpr2(ts18.createObjectLiteral(decoratedMembers));
-  }
-  return {
-    type: new WrappedNodeExpr2(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 WrappedNodeExpr2(ts18.createArrayLiteral(ngDecorators));
-    mapEntries.push({ key: "decorators", value, quoted: false });
-  }
-  return literalMap(mapEntries);
-}
-function classMemberToMetadata(name, decorators, isCore) {
-  const ngDecorators = decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(decorator));
-  const decoratorMeta = ts18.createArrayLiteral(ngDecorators);
-  return ts18.createPropertyAssignment(name, decoratorMeta);
-}
-function decoratorToMetadata(decorator, wrapFunctionsInParens) {
-  if (decorator.identifier === null) {
-    throw new Error("Illegal state: synthesized decorator cannot be emitted in class metadata.");
-  }
-  const properties = [
-    ts18.createPropertyAssignment("type", ts18.getMutableClone(decorator.identifier))
-  ];
-  if (decorator.args !== null && decorator.args.length > 0) {
-    const args = decorator.args.map((arg) => {
-      const expr = ts18.getMutableClone(arg);
-      return wrapFunctionsInParens ? wrapFunctionExpressionsInParens(expr) : expr;
-    });
-    properties.push(ts18.createPropertyAssignment("args", ts18.createArrayLiteral(args)));
-  }
-  return ts18.createObjectLiteral(properties, true);
-}
-function isAngularDecorator2(decorator, isCore) {
-  return isCore || decorator.import !== null && decorator.import.from === "@angular/core";
-}
-function removeIdentifierReferences(node, name) {
-  const result = ts18.transform(node, [(context) => (root) => ts18.visitNode(root, function walk(current) {
-    return ts18.isIdentifier(current) && current.text === name ? ts18.createIdentifier(current.text) : ts18.visitEachChild(current, walk, context);
-  })]);
-  return result.transformed[0];
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/directive.mjs
-var EMPTY_OBJECT = {};
-var FIELD_DECORATORS = [
-  "Input",
-  "Output",
-  "ViewChild",
-  "ViewChildren",
-  "ContentChild",
-  "ContentChildren",
-  "HostBinding",
-  "HostListener"
-];
-var LIFECYCLE_HOOKS = /* @__PURE__ */ new Set([
-  "ngOnChanges",
-  "ngOnInit",
-  "ngOnDestroy",
-  "ngDoCheck",
-  "ngAfterViewInit",
-  "ngAfterViewChecked",
-  "ngAfterContentInit",
-  "ngAfterContentChecked"
-]);
-var DirectiveSymbol = class extends SemanticSymbol {
-  constructor(decl, selector, inputs, outputs, exportAs, typeCheckMeta, typeParameters) {
-    super(decl);
-    this.selector = selector;
-    this.inputs = inputs;
-    this.outputs = outputs;
-    this.exportAs = exportAs;
-    this.typeCheckMeta = typeCheckMeta;
-    this.typeParameters = typeParameters;
-    this.baseClass = null;
-  }
-  isPublicApiAffected(previousSymbol) {
-    if (!(previousSymbol instanceof DirectiveSymbol)) {
-      return true;
-    }
-    return this.selector !== previousSymbol.selector || !isArrayEqual(this.inputs.propertyNames, previousSymbol.inputs.propertyNames) || !isArrayEqual(this.outputs.propertyNames, previousSymbol.outputs.propertyNames) || !isArrayEqual(this.exportAs, previousSymbol.exportAs);
-  }
-  isTypeCheckApiAffected(previousSymbol) {
-    if (this.isPublicApiAffected(previousSymbol)) {
-      return true;
-    }
-    if (!(previousSymbol instanceof DirectiveSymbol)) {
-      return true;
-    }
-    if (!isArrayEqual(Array.from(this.inputs), Array.from(previousSymbol.inputs), isInputMappingEqual) || !isArrayEqual(Array.from(this.outputs), Array.from(previousSymbol.outputs), isInputMappingEqual)) {
-      return true;
-    }
-    if (!areTypeParametersEqual(this.typeParameters, previousSymbol.typeParameters)) {
-      return true;
-    }
-    if (!isTypeCheckMetaEqual(this.typeCheckMeta, previousSymbol.typeCheckMeta)) {
-      return true;
-    }
-    if (!isBaseClassEqual(this.baseClass, previousSymbol.baseClass)) {
-      return true;
-    }
-    return false;
-  }
-};
-function isInputMappingEqual(current, previous) {
-  return current[0] === previous[0] && current[1] === previous[1];
-}
-function isTypeCheckMetaEqual(current, previous) {
-  if (current.hasNgTemplateContextGuard !== previous.hasNgTemplateContextGuard) {
-    return false;
-  }
-  if (current.isGeneric !== previous.isGeneric) {
-    return false;
-  }
-  if (!isArrayEqual(current.ngTemplateGuards, previous.ngTemplateGuards, isTemplateGuardEqual)) {
-    return false;
-  }
-  if (!isSetEqual(current.coercedInputFields, previous.coercedInputFields)) {
-    return false;
-  }
-  if (!isSetEqual(current.restrictedInputFields, previous.restrictedInputFields)) {
-    return false;
-  }
-  if (!isSetEqual(current.stringLiteralInputFields, previous.stringLiteralInputFields)) {
-    return false;
-  }
-  if (!isSetEqual(current.undeclaredInputFields, previous.undeclaredInputFields)) {
-    return false;
-  }
-  return true;
-}
-function isTemplateGuardEqual(current, previous) {
-  return current.inputName === previous.inputName && current.type === previous.type;
-}
-function isBaseClassEqual(current, previous) {
-  if (current === null || previous === null) {
-    return current === previous;
-  }
-  return isSymbolEqual(current, previous);
-}
-var DirectiveDecoratorHandler = class {
-  constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, isCore, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures, perf) {
-    this.reflector = reflector;
-    this.evaluator = evaluator;
-    this.metaRegistry = metaRegistry;
-    this.scopeRegistry = scopeRegistry;
-    this.metaReader = metaReader;
-    this.injectableRegistry = injectableRegistry;
+    this.importManager = importManager;
+    this.recordWrappedNodeExpr = recordWrappedNodeExpr;
+    this.isClosureCompilerEnabled = isClosureCompilerEnabled;
     this.isCore = isCore;
-    this.semanticDepGraphUpdater = semanticDepGraphUpdater;
-    this.annotateForClosureCompiler = annotateForClosureCompiler;
-    this.compileUndecoratedClassesWithAngularFeatures = compileUndecoratedClassesWithAngularFeatures;
-    this.perf = perf;
-    this.precedence = HandlerPrecedence.PRIMARY;
-    this.name = DirectiveDecoratorHandler.name;
   }
-  detect(node, decorators) {
-    if (!decorators) {
-      const angularField = this.findClassFieldWithAngularFeatures(node);
-      return angularField ? { trigger: angularField.node, decorator: null, metadata: null } : void 0;
+  visitClassDeclaration(node) {
+    if (!this.classCompilationMap.has(node)) {
+      return { node };
+    }
+    const translateOptions = {
+      recordWrappedNode: this.recordWrappedNodeExpr,
+      annotateForClosureCompiler: this.isClosureCompilerEnabled
+    };
+    const statements = [];
+    const members = [...node.members];
+    for (const field of this.classCompilationMap.get(node)) {
+      const exprNode = translateExpression(field.initializer, this.importManager, translateOptions);
+      const property = ts20.factory.createPropertyDeclaration(void 0, [ts20.factory.createToken(ts20.SyntaxKind.StaticKeyword)], field.name, void 0, void 0, exprNode);
+      if (this.isClosureCompilerEnabled) {
+        ts20.addSyntheticLeadingComment(property, ts20.SyntaxKind.MultiLineCommentTrivia, "* @nocollapse ", false);
+      }
+      field.statements.map((stmt) => translateStatement(stmt, this.importManager, translateOptions)).forEach((stmt) => statements.push(stmt));
+      members.push(property);
+    }
+    node = ts20.factory.updateClassDeclaration(node, maybeFilterDecorator(node.decorators, this.compilation.decoratorsFor(node)), node.modifiers, node.name, node.typeParameters, node.heritageClauses || [], members.map((member) => this._stripAngularDecorators(member)));
+    return { node, after: statements };
+  }
+  _angularCoreDecorators(decl) {
+    const decorators = this.reflector.getDecoratorsOfDeclaration(decl);
+    if (decorators === null) {
+      return NO_DECORATORS;
+    }
+    const coreDecorators = decorators.filter((dec) => this.isCore || isFromAngularCore(dec)).map((dec) => dec.node);
+    if (coreDecorators.length > 0) {
+      return new Set(coreDecorators);
     } else {
-      const decorator = findAngularDecorator(decorators, "Directive", this.isCore);
-      return decorator ? { trigger: decorator.node, decorator, metadata: decorator } : void 0;
+      return NO_DECORATORS;
     }
   }
-  analyze(node, decorator, flags = HandlerFlags.NONE) {
-    if (this.compileUndecoratedClassesWithAngularFeatures === false && decorator === null) {
-      return { diagnostics: [getUndecoratedClassWithAngularFeaturesDiagnostic(node)] };
+  _nonCoreDecoratorsOnly(node) {
+    if (node.decorators === void 0) {
+      return void 0;
     }
-    this.perf.eventCount(PerfEvent.AnalyzeDirective);
-    const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.isCore, flags, this.annotateForClosureCompiler);
-    if (directiveResult === void 0) {
-      return {};
+    const coreDecorators = this._angularCoreDecorators(node);
+    if (coreDecorators.size === node.decorators.length) {
+      return void 0;
+    } else if (coreDecorators.size === 0) {
+      return node.decorators;
     }
-    const analysis = directiveResult.metadata;
-    let providersRequiringFactory = null;
-    if (directiveResult !== void 0 && directiveResult.decorator.has("providers")) {
-      providersRequiringFactory = resolveProvidersRequiringFactory(directiveResult.decorator.get("providers"), this.reflector, this.evaluator);
+    const filtered = node.decorators.filter((dec) => !coreDecorators.has(dec));
+    if (filtered.length === 0) {
+      return void 0;
     }
-    return {
-      analysis: {
-        inputs: directiveResult.inputs,
-        outputs: directiveResult.outputs,
-        meta: analysis,
-        classMetadata: extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
-        baseClass: readBaseClass(node, this.reflector, this.evaluator),
-        typeCheckMeta: extractDirectiveTypeCheckMeta(node, directiveResult.inputs, this.reflector),
-        providersRequiringFactory,
-        isPoisoned: false,
-        isStructural: directiveResult.isStructural
-      }
-    };
+    const array = ts20.factory.createNodeArray(filtered);
+    array.pos = node.decorators.pos;
+    array.end = node.decorators.end;
+    return array;
   }
-  symbol(node, analysis) {
-    const typeParameters = extractSemanticTypeParameters(node);
-    return new DirectiveSymbol(node, analysis.meta.selector, analysis.inputs, analysis.outputs, analysis.meta.exportAs, analysis.typeCheckMeta, typeParameters);
+  _stripAngularDecorators(node) {
+    if (ts20.isParameter(node)) {
+      node = ts20.factory.updateParameterDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+    } else if (ts20.isMethodDeclaration(node) && node.decorators !== void 0) {
+      node = ts20.factory.updateMethodDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
+    } else if (ts20.isPropertyDeclaration(node) && node.decorators !== void 0) {
+      node = ts20.factory.updatePropertyDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.questionToken, node.type, node.initializer);
+    } else if (ts20.isGetAccessor(node)) {
+      node = ts20.factory.updateGetAccessorDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.parameters, node.type, node.body);
+    } else if (ts20.isSetAccessor(node)) {
+      node = ts20.factory.updateSetAccessorDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.parameters, node.body);
+    } else if (ts20.isConstructorDeclaration(node)) {
+      const parameters = node.parameters.map((param) => this._stripAngularDecorators(param));
+      node = ts20.factory.updateConstructorDeclaration(node, node.decorators, node.modifiers, parameters, node.body);
+    }
+    return node;
   }
-  register(node, analysis) {
-    const ref = new Reference(node);
-    this.metaRegistry.registerDirectiveMetadata(__spreadProps(__spreadValues({
-      type: MetaType.Directive,
-      ref,
-      name: node.name.text,
-      selector: analysis.meta.selector,
-      exportAs: analysis.meta.exportAs,
-      inputs: analysis.inputs,
-      outputs: analysis.outputs,
-      queries: analysis.meta.queries.map((query) => query.propertyName),
-      isComponent: false,
-      baseClass: analysis.baseClass
-    }, analysis.typeCheckMeta), {
-      isPoisoned: analysis.isPoisoned,
-      isStructural: analysis.isStructural,
-      animationTriggerNames: null
-    }));
-    this.injectableRegistry.registerInjectable(node);
+};
+function transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNode) {
+  const constantPool = new ConstantPool(isClosureCompilerEnabled);
+  const importManager = new ImportManager(importRewriter);
+  const compilationVisitor = new IvyCompilationVisitor(compilation, constantPool);
+  visit(file, compilationVisitor, context);
+  const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore);
+  let sf = visit(file, transformationVisitor, context);
+  const downlevelTranslatedCode = getLocalizeCompileTarget(context) < ts20.ScriptTarget.ES2015;
+  const constants = constantPool.statements.map((stmt) => translateStatement(stmt, importManager, {
+    recordWrappedNode,
+    downlevelTaggedTemplates: downlevelTranslatedCode,
+    downlevelVariableDeclarations: downlevelTranslatedCode,
+    annotateForClosureCompiler: isClosureCompilerEnabled
+  }));
+  const fileOverviewMeta = isClosureCompilerEnabled ? getFileOverviewComment(sf.statements) : null;
+  sf = addImports(importManager, sf, constants);
+  if (fileOverviewMeta !== null) {
+    setFileOverviewComment(sf, fileOverviewMeta);
   }
-  resolve(node, analysis, symbol) {
-    if (this.semanticDepGraphUpdater !== null && analysis.baseClass instanceof Reference) {
-      symbol.baseClass = this.semanticDepGraphUpdater.getSymbol(analysis.baseClass.node);
-    }
-    const diagnostics = [];
-    if (analysis.providersRequiringFactory !== null && analysis.meta.providers instanceof WrappedNodeExpr3) {
-      const providerDiagnostics = getProviderDiagnostics(analysis.providersRequiringFactory, analysis.meta.providers.node, this.injectableRegistry);
-      diagnostics.push(...providerDiagnostics);
+  return sf;
+}
+function getLocalizeCompileTarget(context) {
+  const target = context.getCompilerOptions().target || ts20.ScriptTarget.ES2015;
+  return target !== ts20.ScriptTarget.JSON ? target : ts20.ScriptTarget.ES2015;
+}
+function getFileOverviewComment(statements) {
+  if (statements.length > 0) {
+    const host = statements[0];
+    let trailing = false;
+    let comments = ts20.getSyntheticLeadingComments(host);
+    if (!comments || comments.length === 0) {
+      trailing = true;
+      comments = ts20.getSyntheticTrailingComments(host);
     }
-    const directiveDiagnostics = getDirectiveDiagnostics(node, this.metaReader, this.evaluator, this.reflector, this.scopeRegistry, "Directive");
-    if (directiveDiagnostics !== null) {
-      diagnostics.push(...directiveDiagnostics);
+    if (comments && comments.length > 0 && CLOSURE_FILE_OVERVIEW_REGEXP.test(comments[0].text)) {
+      return { comments, host, trailing };
     }
-    return { diagnostics: diagnostics.length > 0 ? diagnostics : void 0 };
   }
-  compileFull(node, analysis, resolution, pool) {
-    const fac = compileNgFactoryDefField(toFactoryMetadata(analysis.meta, FactoryTarget.Directive));
-    const def = compileDirectiveFromMetadata(analysis.meta, pool, makeBindingParser());
-    const classMetadata = analysis.classMetadata !== null ? compileClassMetadata(analysis.classMetadata).toStmt() : null;
-    return compileResults(fac, def, classMetadata, "\u0275dir");
+  return null;
+}
+function setFileOverviewComment(sf, fileoverview) {
+  const { comments, host, trailing } = fileoverview;
+  if (sf.statements.length > 0 && host !== sf.statements[0]) {
+    if (trailing) {
+      ts20.setSyntheticTrailingComments(host, void 0);
+    } else {
+      ts20.setSyntheticLeadingComments(host, void 0);
+    }
+    ts20.setSyntheticLeadingComments(sf.statements[0], comments);
   }
-  compilePartial(node, analysis, resolution) {
-    const fac = compileDeclareFactory(toFactoryMetadata(analysis.meta, FactoryTarget.Directive));
-    const def = compileDeclareDirectiveFromMetadata(analysis.meta);
-    const classMetadata = analysis.classMetadata !== null ? compileDeclareClassMetadata(analysis.classMetadata).toStmt() : null;
-    return compileResults(fac, def, classMetadata, "\u0275dir");
+}
+function maybeFilterDecorator(decorators, toRemove) {
+  if (decorators === void 0) {
+    return void 0;
   }
-  findClassFieldWithAngularFeatures(node) {
-    return this.reflector.getMembersOfClass(node).find((member) => {
-      if (!member.isStatic && member.kind === ClassMemberKind.Method && LIFECYCLE_HOOKS.has(member.name)) {
-        return true;
-      }
-      if (member.decorators) {
-        return member.decorators.some((decorator) => FIELD_DECORATORS.some((decoratorName) => isAngularDecorator(decorator, decoratorName, this.isCore)));
-      }
-      return false;
-    });
+  const filtered = decorators.filter((dec) => toRemove.find((decToRemove) => ts20.getOriginalNode(dec) === decToRemove) === void 0);
+  if (filtered.length === 0) {
+    return void 0;
   }
-};
+  return ts20.factory.createNodeArray(filtered);
+}
+function isFromAngularCore(decorator) {
+  return decorator.import !== null && decorator.import.from === "@angular/core";
+}
+function createRecorderFn(defaultImportTracker) {
+  return (node) => {
+    const importDecl = getDefaultImportDeclaration(node);
+    if (importDecl !== null) {
+      defaultImportTracker.recordUsedImport(importDecl);
+    }
+  };
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/handler.mjs
+import { compileClassMetadata, compileDeclareClassMetadata, compileDeclareDirectiveFromMetadata, compileDirectiveFromMetadata, FactoryTarget, makeBindingParser, WrappedNodeExpr as WrappedNodeExpr5 } from "@angular/compiler";
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.mjs
+import { createMayBeForwardRefExpression, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr3, getSafePropertyAccessString, parseHostBindings, verifyHostBindings, WrappedNodeExpr as WrappedNodeExpr4 } from "@angular/compiler";
+import ts21 from "typescript";
+var EMPTY_OBJECT = {};
+var QUERY_TYPES = /* @__PURE__ */ new Set([
+  "ContentChild",
+  "ContentChildren",
+  "ViewChild",
+  "ViewChildren"
+]);
 function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, isCore, flags, annotateForClosureCompiler, defaultSelector = null) {
   let directive;
   if (decorator === null || decorator.args === null || decorator.args.length === 0) {
@@ -3942,7 +3792,7 @@ function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, isCore
     throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @${decorator.name} decorator`);
   } else {
     const meta = unwrapExpression(decorator.args[0]);
-    if (!ts19.isObjectLiteralExpression(meta)) {
+    if (!ts21.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `@${decorator.name} argument must be an object literal`);
     }
     directive = reflectObjectLiteral(meta);
@@ -3981,7 +3831,7 @@ function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, isCore
     }
   }
   const host = extractHostBindings(decoratedElements, evaluator, coreModule, directive);
-  const providers = directive.has("providers") ? new WrappedNodeExpr3(annotateForClosureCompiler ? wrapFunctionExpressionsInParens(directive.get("providers")) : directive.get("providers")) : null;
+  const providers = directive.has("providers") ? new WrappedNodeExpr4(annotateForClosureCompiler ? wrapFunctionExpressionsInParens(directive.get("providers")) : directive.get("providers")) : null;
   const usesOnChanges = members.some((member) => !member.isStatic && member.kind === ClassMemberKind.Method && member.name === "ngOnChanges");
   let exportAs = null;
   if (directive.has("exportAs")) {
@@ -3995,9 +3845,18 @@ function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, isCore
   const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
   const ctorDeps = selector !== null ? validateConstructorDependencies(clazz, rawCtorDeps) : unwrapConstructorDependencies(rawCtorDeps);
   const isStructural = ctorDeps !== null && ctorDeps !== "invalid" && ctorDeps.some((dep) => dep.token instanceof ExternalExpr3 && dep.token.value.moduleName === "@angular/core" && dep.token.value.name === "TemplateRef");
+  let isStandalone = false;
+  if (directive.has("standalone")) {
+    const expr = directive.get("standalone");
+    const resolved = evaluator.evaluate(expr);
+    if (typeof resolved !== "boolean") {
+      throw createValueHasWrongTypeError(expr, resolved, `standalone flag must be a boolean`);
+    }
+    isStandalone = resolved;
+  }
   const usesInheritance = reflector.hasBaseClass(clazz);
   const type = wrapTypeReference(reflector, clazz);
-  const internalType = new WrappedNodeExpr3(reflector.getInternalNameOfClass(clazz));
+  const internalType = new WrappedNodeExpr4(reflector.getInternalNameOfClass(clazz));
   const inputs = ClassPropertyMapping.fromMappedObject(__spreadValues(__spreadValues({}, inputsFromMeta), inputsFromFields));
   const outputs = ClassPropertyMapping.fromMappedObject(__spreadValues(__spreadValues({}, outputsFromMeta), outputsFromFields));
   const metadata = {
@@ -4019,7 +3878,8 @@ function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, isCore
     typeSourceSpan: createSourceSpan(clazz.name),
     usesInheritance,
     exportAs,
-    providers
+    providers,
+    isStandalone
   };
   return {
     decorator: directive,
@@ -4040,7 +3900,7 @@ function extractQueryMetadata(exprNode, name, args, propertyName, reflector, eva
   let isStatic = false;
   let predicate = null;
   if (arg instanceof Reference || arg instanceof DynamicValue) {
-    predicate = createMayBeForwardRefExpression(new WrappedNodeExpr3(node), forwardReferenceTarget !== null ? 2 : 0);
+    predicate = createMayBeForwardRefExpression(new WrappedNodeExpr4(node), forwardReferenceTarget !== null ? 2 : 0);
   } else if (typeof arg === "string") {
     predicate = [arg];
   } else if (isStringArrayOrDie(arg, `@${name} predicate`, node)) {
@@ -4053,12 +3913,12 @@ function extractQueryMetadata(exprNode, name, args, propertyName, reflector, eva
   let emitDistinctChangesOnly = emitDistinctChangesOnlyDefaultValue;
   if (args.length === 2) {
     const optionsExpr = unwrapExpression(args[1]);
-    if (!ts19.isObjectLiteralExpression(optionsExpr)) {
+    if (!ts21.isObjectLiteralExpression(optionsExpr)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, optionsExpr, `@${name} options must be an object literal`);
     }
     const options = reflectObjectLiteral(optionsExpr);
     if (options.has("read")) {
-      read = new WrappedNodeExpr3(options.get("read"));
+      read = new WrappedNodeExpr4(options.get("read"));
     }
     if (options.has("descendants")) {
       const descendantsExpr = options.get("descendants");
@@ -4096,18 +3956,68 @@ function extractQueryMetadata(exprNode, name, args, propertyName, reflector, eva
     emitDistinctChangesOnly
   };
 }
+function extractHostBindings(members, evaluator, coreModule, metadata) {
+  let bindings;
+  if (metadata && metadata.has("host")) {
+    bindings = evaluateHostExpressionBindings(metadata.get("host"), evaluator);
+  } else {
+    bindings = parseHostBindings({});
+  }
+  filterToMembersWithDecorator(members, "HostBinding", coreModule).forEach(({ member, decorators }) => {
+    decorators.forEach((decorator) => {
+      let hostPropertyName = member.name;
+      if (decorator.args !== null && decorator.args.length > 0) {
+        if (decorator.args.length !== 1) {
+          throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `@HostBinding can have at most one argument, got ${decorator.args.length} argument(s)`);
+        }
+        const resolved = evaluator.evaluate(decorator.args[0]);
+        if (typeof resolved !== "string") {
+          throw createValueHasWrongTypeError(Decorator.nodeForError(decorator), resolved, `@HostBinding's argument must be a string`);
+        }
+        hostPropertyName = resolved;
+      }
+      bindings.properties[hostPropertyName] = getSafePropertyAccessString("this", member.name);
+    });
+  });
+  filterToMembersWithDecorator(members, "HostListener", coreModule).forEach(({ member, decorators }) => {
+    decorators.forEach((decorator) => {
+      let eventName = member.name;
+      let args = [];
+      if (decorator.args !== null && decorator.args.length > 0) {
+        if (decorator.args.length > 2) {
+          throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.args[2], `@HostListener can have at most two arguments`);
+        }
+        const resolved = evaluator.evaluate(decorator.args[0]);
+        if (typeof resolved !== "string") {
+          throw createValueHasWrongTypeError(decorator.args[0], resolved, `@HostListener's event name argument must be a string`);
+        }
+        eventName = resolved;
+        if (decorator.args.length === 2) {
+          const expression = decorator.args[1];
+          const resolvedArgs = evaluator.evaluate(decorator.args[1]);
+          if (!isStringArrayOrDie(resolvedArgs, "@HostListener.args", expression)) {
+            throw createValueHasWrongTypeError(decorator.args[1], resolvedArgs, `@HostListener's second argument must be a string array`);
+          }
+          args = resolvedArgs;
+        }
+      }
+      bindings.listeners[eventName] = `${member.name}(${args.join(",")})`;
+    });
+  });
+  return bindings;
+}
 function extractQueriesFromDecorator(queryData, reflector, evaluator, isCore) {
   const content = [], view = [];
-  if (!ts19.isObjectLiteralExpression(queryData)) {
+  if (!ts21.isObjectLiteralExpression(queryData)) {
     throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, "Decorator queries metadata must be an object literal");
   }
   reflectObjectLiteral(queryData).forEach((queryExpr, propertyName) => {
     queryExpr = unwrapExpression(queryExpr);
-    if (!ts19.isNewExpression(queryExpr)) {
+    if (!ts21.isNewExpression(queryExpr)) {
       throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, "Decorator query metadata must be an instance of a query type");
     }
-    const queryType = ts19.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
-    if (!ts19.isIdentifier(queryType)) {
+    const queryType = ts21.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
+    if (!ts21.isIdentifier(queryType)) {
       throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, "Decorator query metadata must be an instance of a query type");
     }
     const type = reflector.getImportOfIdentifier(queryType);
@@ -4123,6 +4033,17 @@ function extractQueriesFromDecorator(queryData, reflector, evaluator, isCore) {
   });
   return { content, view };
 }
+function parseFieldArrayValue(directive, field, evaluator) {
+  if (!directive.has(field)) {
+    return null;
+  }
+  const expression = directive.get(field);
+  const value = evaluator.evaluate(expression);
+  if (!isStringArrayOrDie(value, field, expression)) {
+    throw createValueHasWrongTypeError(expression, value, `Failed to resolve @Directive.${field} to a string array`);
+  }
+  return value;
+}
 function isStringArrayOrDie(value, name, node) {
   if (!Array.isArray(value)) {
     return false;
@@ -4134,16 +4055,23 @@ function isStringArrayOrDie(value, name, node) {
   }
   return true;
 }
-function parseFieldArrayValue(directive, field, evaluator) {
-  if (!directive.has(field)) {
-    return null;
-  }
-  const expression = directive.get(field);
-  const value = evaluator.evaluate(expression);
-  if (!isStringArrayOrDie(value, field, expression)) {
-    throw createValueHasWrongTypeError(expression, value, `Failed to resolve @Directive.${field} to a string array`);
-  }
-  return value;
+function queriesFromFields(fields, reflector, evaluator) {
+  return fields.map(({ member, decorators }) => {
+    const decorator = decorators[0];
+    const node = member.node || Decorator.nodeForError(decorator);
+    if (member.decorators.some((v) => v.name === "Input")) {
+      throw new FatalDiagnosticError(ErrorCode.DECORATOR_COLLISION, node, "Cannot combine @Input decorators with query decorators");
+    }
+    if (decorators.length !== 1) {
+      throw new FatalDiagnosticError(ErrorCode.DECORATOR_COLLISION, node, "Cannot have multiple query decorators on the same class member");
+    } else if (!isPropertyTypeMember(member)) {
+      throw new FatalDiagnosticError(ErrorCode.DECORATOR_UNEXPECTED, node, "Query decorator must go on a property-type member");
+    }
+    return extractQueryMetadata(node, decorator.name, decorator.args || [], member.name, reflector, evaluator);
+  });
+}
+function isPropertyTypeMember(member) {
+  return member.kind === ClassMemberKind.Getter || member.kind === ClassMemberKind.Setter || member.kind === ClassMemberKind.Property;
 }
 function parseFieldToPropertyMapping(directive, field, evaluator) {
   const metaValues = parseFieldArrayValue(directive, field, evaluator);
@@ -4181,112 +4109,254 @@ function resolveInput(publicName, internalName) {
 function resolveOutput(publicName, internalName) {
   return publicName;
 }
-function queriesFromFields(fields, reflector, evaluator) {
-  return fields.map(({ member, decorators }) => {
-    const decorator = decorators[0];
-    const node = member.node || Decorator.nodeForError(decorator);
-    if (member.decorators.some((v) => v.name === "Input")) {
-      throw new FatalDiagnosticError(ErrorCode.DECORATOR_COLLISION, node, "Cannot combine @Input decorators with query decorators");
+function evaluateHostExpressionBindings(hostExpr, evaluator) {
+  const hostMetaMap = evaluator.evaluate(hostExpr);
+  if (!(hostMetaMap instanceof Map)) {
+    throw createValueHasWrongTypeError(hostExpr, hostMetaMap, `Decorator host metadata must be an object`);
+  }
+  const hostMetadata = {};
+  hostMetaMap.forEach((value, key) => {
+    if (value instanceof EnumValue) {
+      value = value.resolved;
     }
-    if (decorators.length !== 1) {
-      throw new FatalDiagnosticError(ErrorCode.DECORATOR_COLLISION, node, "Cannot have multiple query decorators on the same class member");
-    } else if (!isPropertyTypeMember(member)) {
-      throw new FatalDiagnosticError(ErrorCode.DECORATOR_UNEXPECTED, node, "Query decorator must go on a property-type member");
+    if (typeof key !== "string") {
+      throw createValueHasWrongTypeError(hostExpr, key, `Decorator host metadata must be a string -> string object, but found unparseable key`);
+    }
+    if (typeof value == "string") {
+      hostMetadata[key] = value;
+    } else if (value instanceof DynamicValue) {
+      hostMetadata[key] = new WrappedNodeExpr4(value.node);
+    } else {
+      throw createValueHasWrongTypeError(hostExpr, value, `Decorator host metadata must be a string -> string object, but found unparseable value`);
     }
-    return extractQueryMetadata(node, decorator.name, decorator.args || [], member.name, reflector, evaluator);
   });
+  const bindings = parseHostBindings(hostMetadata);
+  const errors = verifyHostBindings(bindings, createSourceSpan(hostExpr));
+  if (errors.length > 0) {
+    throw new FatalDiagnosticError(ErrorCode.HOST_BINDING_PARSE_ERROR, hostExpr, errors.map((error) => error.msg).join("\n"));
+  }
+  return bindings;
 }
-function isPropertyTypeMember(member) {
-  return member.kind === ClassMemberKind.Getter || member.kind === ClassMemberKind.Setter || member.kind === ClassMemberKind.Property;
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/symbol.mjs
+var DirectiveSymbol = class extends SemanticSymbol {
+  constructor(decl, selector, inputs, outputs, exportAs, typeCheckMeta, typeParameters) {
+    super(decl);
+    this.selector = selector;
+    this.inputs = inputs;
+    this.outputs = outputs;
+    this.exportAs = exportAs;
+    this.typeCheckMeta = typeCheckMeta;
+    this.typeParameters = typeParameters;
+    this.baseClass = null;
+  }
+  isPublicApiAffected(previousSymbol) {
+    if (!(previousSymbol instanceof DirectiveSymbol)) {
+      return true;
+    }
+    return this.selector !== previousSymbol.selector || !isArrayEqual(this.inputs.propertyNames, previousSymbol.inputs.propertyNames) || !isArrayEqual(this.outputs.propertyNames, previousSymbol.outputs.propertyNames) || !isArrayEqual(this.exportAs, previousSymbol.exportAs);
+  }
+  isTypeCheckApiAffected(previousSymbol) {
+    if (this.isPublicApiAffected(previousSymbol)) {
+      return true;
+    }
+    if (!(previousSymbol instanceof DirectiveSymbol)) {
+      return true;
+    }
+    if (!isArrayEqual(Array.from(this.inputs), Array.from(previousSymbol.inputs), isInputMappingEqual) || !isArrayEqual(Array.from(this.outputs), Array.from(previousSymbol.outputs), isInputMappingEqual)) {
+      return true;
+    }
+    if (!areTypeParametersEqual(this.typeParameters, previousSymbol.typeParameters)) {
+      return true;
+    }
+    if (!isTypeCheckMetaEqual(this.typeCheckMeta, previousSymbol.typeCheckMeta)) {
+      return true;
+    }
+    if (!isBaseClassEqual(this.baseClass, previousSymbol.baseClass)) {
+      return true;
+    }
+    return false;
+  }
+};
+function isInputMappingEqual(current, previous) {
+  return current[0] === previous[0] && current[1] === previous[1];
 }
-function evaluateHostExpressionBindings(hostExpr, evaluator) {
-  const hostMetaMap = evaluator.evaluate(hostExpr);
-  if (!(hostMetaMap instanceof Map)) {
-    throw createValueHasWrongTypeError(hostExpr, hostMetaMap, `Decorator host metadata must be an object`);
+function isTypeCheckMetaEqual(current, previous) {
+  if (current.hasNgTemplateContextGuard !== previous.hasNgTemplateContextGuard) {
+    return false;
+  }
+  if (current.isGeneric !== previous.isGeneric) {
+    return false;
+  }
+  if (!isArrayEqual(current.ngTemplateGuards, previous.ngTemplateGuards, isTemplateGuardEqual)) {
+    return false;
+  }
+  if (!isSetEqual(current.coercedInputFields, previous.coercedInputFields)) {
+    return false;
+  }
+  if (!isSetEqual(current.restrictedInputFields, previous.restrictedInputFields)) {
+    return false;
+  }
+  if (!isSetEqual(current.stringLiteralInputFields, previous.stringLiteralInputFields)) {
+    return false;
+  }
+  if (!isSetEqual(current.undeclaredInputFields, previous.undeclaredInputFields)) {
+    return false;
+  }
+  return true;
+}
+function isTemplateGuardEqual(current, previous) {
+  return current.inputName === previous.inputName && current.type === previous.type;
+}
+function isBaseClassEqual(current, previous) {
+  if (current === null || previous === null) {
+    return current === previous;
+  }
+  return isSymbolEqual(current, previous);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/handler.mjs
+var FIELD_DECORATORS = [
+  "Input",
+  "Output",
+  "ViewChild",
+  "ViewChildren",
+  "ContentChild",
+  "ContentChildren",
+  "HostBinding",
+  "HostListener"
+];
+var LIFECYCLE_HOOKS = /* @__PURE__ */ new Set([
+  "ngOnChanges",
+  "ngOnInit",
+  "ngOnDestroy",
+  "ngDoCheck",
+  "ngAfterViewInit",
+  "ngAfterViewChecked",
+  "ngAfterContentInit",
+  "ngAfterContentChecked"
+]);
+var DirectiveDecoratorHandler = class {
+  constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, isCore, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures, perf) {
+    this.reflector = reflector;
+    this.evaluator = evaluator;
+    this.metaRegistry = metaRegistry;
+    this.scopeRegistry = scopeRegistry;
+    this.metaReader = metaReader;
+    this.injectableRegistry = injectableRegistry;
+    this.isCore = isCore;
+    this.semanticDepGraphUpdater = semanticDepGraphUpdater;
+    this.annotateForClosureCompiler = annotateForClosureCompiler;
+    this.compileUndecoratedClassesWithAngularFeatures = compileUndecoratedClassesWithAngularFeatures;
+    this.perf = perf;
+    this.precedence = HandlerPrecedence.PRIMARY;
+    this.name = DirectiveDecoratorHandler.name;
+  }
+  detect(node, decorators) {
+    if (!decorators) {
+      const angularField = this.findClassFieldWithAngularFeatures(node);
+      return angularField ? { trigger: angularField.node, decorator: null, metadata: null } : void 0;
+    } else {
+      const decorator = findAngularDecorator(decorators, "Directive", this.isCore);
+      return decorator ? { trigger: decorator.node, decorator, metadata: decorator } : void 0;
+    }
+  }
+  analyze(node, decorator, flags = HandlerFlags.NONE) {
+    if (this.compileUndecoratedClassesWithAngularFeatures === false && decorator === null) {
+      return { diagnostics: [getUndecoratedClassWithAngularFeaturesDiagnostic(node)] };
+    }
+    this.perf.eventCount(PerfEvent.AnalyzeDirective);
+    const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.isCore, flags, this.annotateForClosureCompiler);
+    if (directiveResult === void 0) {
+      return {};
+    }
+    const analysis = directiveResult.metadata;
+    let providersRequiringFactory = null;
+    if (directiveResult !== void 0 && directiveResult.decorator.has("providers")) {
+      providersRequiringFactory = resolveProvidersRequiringFactory(directiveResult.decorator.get("providers"), this.reflector, this.evaluator);
+    }
+    return {
+      analysis: {
+        inputs: directiveResult.inputs,
+        outputs: directiveResult.outputs,
+        meta: analysis,
+        classMetadata: extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
+        baseClass: readBaseClass(node, this.reflector, this.evaluator),
+        typeCheckMeta: extractDirectiveTypeCheckMeta(node, directiveResult.inputs, this.reflector),
+        providersRequiringFactory,
+        isPoisoned: false,
+        isStructural: directiveResult.isStructural
+      }
+    };
+  }
+  symbol(node, analysis) {
+    const typeParameters = extractSemanticTypeParameters(node);
+    return new DirectiveSymbol(node, analysis.meta.selector, analysis.inputs, analysis.outputs, analysis.meta.exportAs, analysis.typeCheckMeta, typeParameters);
+  }
+  register(node, analysis) {
+    const ref = new Reference(node);
+    this.metaRegistry.registerDirectiveMetadata(__spreadProps(__spreadValues({
+      type: MetaType.Directive,
+      ref,
+      name: node.name.text,
+      selector: analysis.meta.selector,
+      exportAs: analysis.meta.exportAs,
+      inputs: analysis.inputs,
+      outputs: analysis.outputs,
+      queries: analysis.meta.queries.map((query) => query.propertyName),
+      isComponent: false,
+      baseClass: analysis.baseClass
+    }, analysis.typeCheckMeta), {
+      isPoisoned: analysis.isPoisoned,
+      isStructural: analysis.isStructural,
+      animationTriggerNames: null,
+      isStandalone: analysis.meta.isStandalone
+    }));
+    this.injectableRegistry.registerInjectable(node);
   }
-  const hostMetadata = {};
-  hostMetaMap.forEach((value, key) => {
-    if (value instanceof EnumValue) {
-      value = value.resolved;
+  resolve(node, analysis, symbol) {
+    if (this.semanticDepGraphUpdater !== null && analysis.baseClass instanceof Reference) {
+      symbol.baseClass = this.semanticDepGraphUpdater.getSymbol(analysis.baseClass.node);
     }
-    if (typeof key !== "string") {
-      throw createValueHasWrongTypeError(hostExpr, key, `Decorator host metadata must be a string -> string object, but found unparseable key`);
+    const diagnostics = [];
+    if (analysis.providersRequiringFactory !== null && analysis.meta.providers instanceof WrappedNodeExpr5) {
+      const providerDiagnostics = getProviderDiagnostics(analysis.providersRequiringFactory, analysis.meta.providers.node, this.injectableRegistry);
+      diagnostics.push(...providerDiagnostics);
     }
-    if (typeof value == "string") {
-      hostMetadata[key] = value;
-    } else if (value instanceof DynamicValue) {
-      hostMetadata[key] = new WrappedNodeExpr3(value.node);
-    } else {
-      throw createValueHasWrongTypeError(hostExpr, value, `Decorator host metadata must be a string -> string object, but found unparseable value`);
+    const directiveDiagnostics = getDirectiveDiagnostics(node, this.metaReader, this.evaluator, this.reflector, this.scopeRegistry, "Directive");
+    if (directiveDiagnostics !== null) {
+      diagnostics.push(...directiveDiagnostics);
     }
-  });
-  const bindings = parseHostBindings(hostMetadata);
-  const errors = verifyHostBindings(bindings, createSourceSpan(hostExpr));
-  if (errors.length > 0) {
-    throw new FatalDiagnosticError(ErrorCode.HOST_BINDING_PARSE_ERROR, hostExpr, errors.map((error) => error.msg).join("\n"));
+    return { diagnostics: diagnostics.length > 0 ? diagnostics : void 0 };
   }
-  return bindings;
-}
-function extractHostBindings(members, evaluator, coreModule, metadata) {
-  let bindings;
-  if (metadata && metadata.has("host")) {
-    bindings = evaluateHostExpressionBindings(metadata.get("host"), evaluator);
-  } else {
-    bindings = parseHostBindings({});
+  compileFull(node, analysis, resolution, pool) {
+    const fac = compileNgFactoryDefField(toFactoryMetadata(analysis.meta, FactoryTarget.Directive));
+    const def = compileDirectiveFromMetadata(analysis.meta, pool, makeBindingParser());
+    const classMetadata = analysis.classMetadata !== null ? compileClassMetadata(analysis.classMetadata).toStmt() : null;
+    return compileResults(fac, def, classMetadata, "\u0275dir");
   }
-  filterToMembersWithDecorator(members, "HostBinding", coreModule).forEach(({ member, decorators }) => {
-    decorators.forEach((decorator) => {
-      let hostPropertyName = member.name;
-      if (decorator.args !== null && decorator.args.length > 0) {
-        if (decorator.args.length !== 1) {
-          throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `@HostBinding can have at most one argument, got ${decorator.args.length} argument(s)`);
-        }
-        const resolved = evaluator.evaluate(decorator.args[0]);
-        if (typeof resolved !== "string") {
-          throw createValueHasWrongTypeError(Decorator.nodeForError(decorator), resolved, `@HostBinding's argument must be a string`);
-        }
-        hostPropertyName = resolved;
+  compilePartial(node, analysis, resolution) {
+    const fac = compileDeclareFactory(toFactoryMetadata(analysis.meta, FactoryTarget.Directive));
+    const def = compileDeclareDirectiveFromMetadata(analysis.meta);
+    const classMetadata = analysis.classMetadata !== null ? compileDeclareClassMetadata(analysis.classMetadata).toStmt() : null;
+    return compileResults(fac, def, classMetadata, "\u0275dir");
+  }
+  findClassFieldWithAngularFeatures(node) {
+    return this.reflector.getMembersOfClass(node).find((member) => {
+      if (!member.isStatic && member.kind === ClassMemberKind.Method && LIFECYCLE_HOOKS.has(member.name)) {
+        return true;
       }
-      bindings.properties[hostPropertyName] = getSafePropertyAccessString("this", member.name);
-    });
-  });
-  filterToMembersWithDecorator(members, "HostListener", coreModule).forEach(({ member, decorators }) => {
-    decorators.forEach((decorator) => {
-      let eventName = member.name;
-      let args = [];
-      if (decorator.args !== null && decorator.args.length > 0) {
-        if (decorator.args.length > 2) {
-          throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.args[2], `@HostListener can have at most two arguments`);
-        }
-        const resolved = evaluator.evaluate(decorator.args[0]);
-        if (typeof resolved !== "string") {
-          throw createValueHasWrongTypeError(decorator.args[0], resolved, `@HostListener's event name argument must be a string`);
-        }
-        eventName = resolved;
-        if (decorator.args.length === 2) {
-          const expression = decorator.args[1];
-          const resolvedArgs = evaluator.evaluate(decorator.args[1]);
-          if (!isStringArrayOrDie(resolvedArgs, "@HostListener.args", expression)) {
-            throw createValueHasWrongTypeError(decorator.args[1], resolvedArgs, `@HostListener's second argument must be a string array`);
-          }
-          args = resolvedArgs;
-        }
+      if (member.decorators) {
+        return member.decorators.some((decorator) => FIELD_DECORATORS.some((decoratorName) => isAngularDecorator(decorator, decoratorName, this.isCore)));
       }
-      bindings.listeners[eventName] = `${member.name}(${args.join(",")})`;
+      return false;
     });
-  });
-  return bindings;
-}
-var QUERY_TYPES = /* @__PURE__ */ new Set([
-  "ContentChild",
-  "ContentChildren",
-  "ViewChild",
-  "ViewChildren"
-]);
+  }
+};
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/ng_module.mjs
-import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, CUSTOM_ELEMENTS_SCHEMA, ExternalExpr as ExternalExpr4, FactoryTarget as FactoryTarget2, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr2, NO_ERRORS_SCHEMA, R3Identifiers, WrappedNodeExpr as WrappedNodeExpr4 } from "@angular/compiler";
-import ts20 from "typescript";
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.mjs
+import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, CUSTOM_ELEMENTS_SCHEMA, ExternalExpr as ExternalExpr4, FactoryTarget as FactoryTarget2, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr2, NO_ERRORS_SCHEMA, R3Identifiers, WrappedNodeExpr as WrappedNodeExpr6 } from "@angular/compiler";
+import ts22 from "typescript";
 var NgModuleSymbol = class extends SemanticSymbol {
   constructor() {
     super(...arguments);
@@ -4369,8 +4439,8 @@ var NgModuleDecoratorHandler = class {
     if (decorator.args === null || decorator.args.length > 1) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @NgModule decorator`);
     }
-    const meta = decorator.args.length === 1 ? unwrapExpression(decorator.args[0]) : ts20.createObjectLiteral([]);
-    if (!ts20.isObjectLiteralExpression(meta)) {
+    const meta = decorator.args.length === 1 ? unwrapExpression(decorator.args[0]) : ts22.factory.createObjectLiteralExpression([]);
+    if (!ts22.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@NgModule argument must be an object literal");
     }
     const ngModule = reflectObjectLiteral(meta);
@@ -4444,7 +4514,7 @@ var NgModuleDecoratorHandler = class {
         }
       }
     }
-    const id = ngModule.has("id") ? new WrappedNodeExpr4(ngModule.get("id")) : null;
+    const id = ngModule.has("id") ? new WrappedNodeExpr6(ngModule.get("id")) : null;
     const valueContext = node.getSourceFile();
     let typeContext = valueContext;
     const typeNode = this.reflector.getDtsDeclaration(node);
@@ -4458,8 +4528,8 @@ var NgModuleDecoratorHandler = class {
     const isForwardReference = (ref) => isExpressionForwardReference(ref.value, node.name, valueContext);
     const containsForwardDecls = bootstrap.some(isForwardReference) || declarations.some(isForwardReference) || imports.some(isForwardReference) || exports.some(isForwardReference);
     const type = wrapTypeReference(this.reflector, node);
-    const internalType = new WrappedNodeExpr4(this.reflector.getInternalNameOfClass(node));
-    const adjacentType = new WrappedNodeExpr4(this.reflector.getAdjacentNameOfClass(node));
+    const internalType = new WrappedNodeExpr6(this.reflector.getInternalNameOfClass(node));
+    const adjacentType = new WrappedNodeExpr6(this.reflector.getAdjacentNameOfClass(node));
     const ngModuleMetadata = {
       type,
       internalType,
@@ -4474,10 +4544,10 @@ var NgModuleDecoratorHandler = class {
       schemas: []
     };
     const rawProviders = ngModule.has("providers") ? ngModule.get("providers") : null;
-    const wrapperProviders = rawProviders !== null ? new WrappedNodeExpr4(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(rawProviders) : rawProviders) : null;
+    const wrapperProviders = rawProviders !== null ? new WrappedNodeExpr6(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(rawProviders) : rawProviders) : null;
     const injectorImports = [];
     if (ngModule.has("imports")) {
-      injectorImports.push(new WrappedNodeExpr4(ngModule.get("imports")));
+      injectorImports.push(new WrappedNodeExpr6(ngModule.get("imports")));
     }
     const injectorMetadata = {
       name,
@@ -4556,9 +4626,20 @@ var NgModuleDecoratorHandler = class {
         }
       }
       for (const decl of analysis.declarations) {
-        const metadata = this.metaReader.getDirectiveMetadata(decl);
-        if (metadata !== null && metadata.selector === null) {
-          throw new FatalDiagnosticError(ErrorCode.DIRECTIVE_MISSING_SELECTOR, decl.node, `Directive ${decl.node.name.text} has no selector, please add it!`);
+        const dirMeta = this.metaReader.getDirectiveMetadata(decl);
+        if (dirMeta !== null) {
+          const refType = dirMeta.isComponent ? "Component" : "Directive";
+          if (dirMeta.selector === null) {
+            throw new FatalDiagnosticError(ErrorCode.DIRECTIVE_MISSING_SELECTOR, decl.node, `${refType} ${decl.node.name.text} has no selector, please add it!`);
+          }
+          if (dirMeta.isStandalone) {
+            diagnostics.push(makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_IS_STANDALONE, decl.getOriginForDiagnostics(analysis.rawDeclarations), `${refType} ${decl.node.name.text} is standalone, and cannot be declared in an NgModule. Did you mean to import it instead?`));
+          }
+          continue;
+        }
+        const pipeMeta = this.metaReader.getPipeMetadata(decl);
+        if (pipeMeta !== null && pipeMeta.isStandalone) {
+          diagnostics.push(makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_IS_STANDALONE, decl.getOriginForDiagnostics(analysis.rawDeclarations), `Pipe ${decl.node.name.text} is standalone, and cannot be declared in an NgModule. Did you mean to import it instead?`));
         }
       }
     }
@@ -4661,10 +4742,10 @@ var NgModuleDecoratorHandler = class {
     return type && (this._reflectModuleFromTypeParam(type, node) || this._reflectModuleFromLiteralType(type));
   }
   _reflectModuleFromTypeParam(type, node) {
-    if (!ts20.isTypeReferenceNode(type)) {
+    if (!ts22.isTypeReferenceNode(type)) {
       return null;
     }
-    const typeName = type && (ts20.isIdentifier(type.typeName) && type.typeName || ts20.isQualifiedName(type.typeName) && type.typeName.right) || null;
+    const typeName = type && (ts22.isIdentifier(type.typeName) && type.typeName || ts22.isQualifiedName(type.typeName) && type.typeName.right) || null;
     if (typeName === null) {
       return null;
     }
@@ -4676,7 +4757,7 @@ var NgModuleDecoratorHandler = class {
       return null;
     }
     if (type.typeArguments === void 0 || type.typeArguments.length !== 1) {
-      const parent = ts20.isMethodDeclaration(node) && ts20.isClassDeclaration(node.parent) ? node.parent : null;
+      const parent = ts22.isMethodDeclaration(node) && ts22.isClassDeclaration(node.parent) ? node.parent : null;
       const symbolName = (parent && parent.name ? parent.name.getText() + "." : "") + (node.name ? node.name.getText() : "anonymous");
       throw new FatalDiagnosticError(ErrorCode.NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC, type, `${symbolName} returns a ModuleWithProviders type without a generic type argument. Please add a generic type argument to the ModuleWithProviders type. If this occurrence is in library code you don't control, please contact the library authors.`);
     }
@@ -4684,13 +4765,13 @@ var NgModuleDecoratorHandler = class {
     return typeNodeToValueExpr(arg);
   }
   _reflectModuleFromLiteralType(type) {
-    if (!ts20.isIntersectionTypeNode(type)) {
+    if (!ts22.isIntersectionTypeNode(type)) {
       return null;
     }
     for (const t of type.types) {
-      if (ts20.isTypeLiteralNode(t)) {
+      if (ts22.isTypeLiteralNode(t)) {
         for (const m of t.members) {
-          const ngModuleType = ts20.isPropertySignature(m) && ts20.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
+          const ngModuleType = ts22.isPropertySignature(m) && ts22.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
           const ngModuleExpression = ngModuleType && typeNodeToValueExpr(ngModuleType);
           if (ngModuleExpression) {
             return ngModuleExpression;
@@ -4718,21 +4799,440 @@ var NgModuleDecoratorHandler = class {
         if (!this.isClassDeclarationReference(entry)) {
           throw createValueHasWrongTypeError(entry.node, entry, `Value at position ${idx} in the NgModule.${arrayName} of ${className} is not a class`);
         }
-        refList.push(entry);
-      } else {
-        throw createValueHasWrongTypeError(expr, entry, `Value at position ${idx} in the NgModule.${arrayName} of ${className} is not a reference`);
+        refList.push(entry);
+      } else {
+        throw createValueHasWrongTypeError(expr, entry, `Value at position ${idx} in the NgModule.${arrayName} of ${className} is not a reference`);
+      }
+    });
+    return refList;
+  }
+};
+function isNgModule(node, compilation) {
+  return !compilation.directives.some((directive) => directive.ref.node === node) && !compilation.pipes.some((pipe) => pipe.ref.node === node);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/diagnostics.mjs
+function makeCyclicImportInfo(ref, type, cycle) {
+  const name = ref.debugName || "(unknown)";
+  const path = cycle.getPath().map((sf) => sf.fileName).join(" -> ");
+  const message = `The ${type} '${name}' is used in the template but importing it would create a cycle: `;
+  return makeRelatedInformation(ref.node, message + path);
+}
+function checkCustomElementSelectorForErrors(selector) {
+  if (selector.includes(".") || selector.includes("[") && selector.includes("]")) {
+    return null;
+  }
+  if (!/^[a-z]/.test(selector)) {
+    return "Selector of a ShadowDom-encapsulated component must start with a lower case letter.";
+  }
+  if (/[A-Z]/.test(selector)) {
+    return "Selector of a ShadowDom-encapsulated component must all be in lower case.";
+  }
+  if (!selector.includes("-")) {
+    return "Selector of a component that uses ViewEncapsulation.ShadowDom must contain a hyphen.";
+  }
+  return null;
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/resources.mjs
+import { DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig, ParseSourceFile as ParseSourceFile2, parseTemplate } from "@angular/compiler";
+import ts23 from "typescript";
+function getTemplateDeclarationNodeForError(declaration) {
+  switch (declaration.isInline) {
+    case true:
+      return declaration.expression;
+    case false:
+      return declaration.templateUrlExpression;
+  }
+}
+function extractTemplate(node, template, evaluator, depTracker, resourceLoader, options) {
+  if (template.isInline) {
+    let sourceStr;
+    let sourceParseRange = null;
+    let templateContent;
+    let sourceMapping;
+    let escapedString = false;
+    let sourceMapUrl;
+    if (ts23.isStringLiteral(template.expression) || ts23.isNoSubstitutionTemplateLiteral(template.expression)) {
+      sourceParseRange = getTemplateRange(template.expression);
+      sourceStr = template.expression.getSourceFile().text;
+      templateContent = template.expression.text;
+      escapedString = true;
+      sourceMapping = {
+        type: "direct",
+        node: template.expression
+      };
+      sourceMapUrl = template.resolvedTemplateUrl;
+    } else {
+      const resolvedTemplate = evaluator.evaluate(template.expression);
+      if (typeof resolvedTemplate !== "string") {
+        throw createValueHasWrongTypeError(template.expression, resolvedTemplate, "template must be a string");
+      }
+      sourceStr = resolvedTemplate;
+      templateContent = resolvedTemplate;
+      sourceMapping = {
+        type: "indirect",
+        node: template.expression,
+        componentClass: node,
+        template: templateContent
+      };
+      sourceMapUrl = null;
+    }
+    return __spreadProps(__spreadValues({}, parseExtractedTemplate(template, sourceStr, sourceParseRange, escapedString, sourceMapUrl, options)), {
+      content: templateContent,
+      sourceMapping,
+      declaration: template
+    });
+  } else {
+    const templateContent = resourceLoader.load(template.resolvedTemplateUrl);
+    if (depTracker !== null) {
+      depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(template.resolvedTemplateUrl));
+    }
+    return __spreadProps(__spreadValues({}, parseExtractedTemplate(template, templateContent, null, false, template.resolvedTemplateUrl, options)), {
+      content: templateContent,
+      sourceMapping: {
+        type: "external",
+        componentClass: node,
+        node: template.templateUrlExpression,
+        template: templateContent,
+        templateUrl: template.resolvedTemplateUrl
+      },
+      declaration: template
+    });
+  }
+}
+function parseExtractedTemplate(template, sourceStr, sourceParseRange, escapedString, sourceMapUrl, options) {
+  const i18nNormalizeLineEndingsInICUs = escapedString || options.i18nNormalizeLineEndingsInICUs;
+  const parsedTemplate = parseTemplate(sourceStr, sourceMapUrl != null ? sourceMapUrl : "", {
+    preserveWhitespaces: template.preserveWhitespaces,
+    interpolationConfig: template.interpolationConfig,
+    range: sourceParseRange != null ? sourceParseRange : void 0,
+    escapedString,
+    enableI18nLegacyMessageIdFormat: options.enableI18nLegacyMessageIdFormat,
+    i18nNormalizeLineEndingsInICUs,
+    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData
+  });
+  const { nodes: diagNodes } = parseTemplate(sourceStr, sourceMapUrl != null ? sourceMapUrl : "", {
+    preserveWhitespaces: true,
+    preserveLineEndings: true,
+    interpolationConfig: template.interpolationConfig,
+    range: sourceParseRange != null ? sourceParseRange : void 0,
+    escapedString,
+    enableI18nLegacyMessageIdFormat: options.enableI18nLegacyMessageIdFormat,
+    i18nNormalizeLineEndingsInICUs,
+    leadingTriviaChars: [],
+    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData
+  });
+  return __spreadProps(__spreadValues({}, parsedTemplate), {
+    diagNodes,
+    file: new ParseSourceFile2(sourceStr, sourceMapUrl != null ? sourceMapUrl : "")
+  });
+}
+function parseTemplateDeclaration(decorator, component, containingFile, evaluator, resourceLoader, defaultPreserveWhitespaces) {
+  let preserveWhitespaces = defaultPreserveWhitespaces;
+  if (component.has("preserveWhitespaces")) {
+    const expr = component.get("preserveWhitespaces");
+    const value = evaluator.evaluate(expr);
+    if (typeof value !== "boolean") {
+      throw createValueHasWrongTypeError(expr, value, "preserveWhitespaces must be a boolean");
+    }
+    preserveWhitespaces = value;
+  }
+  let interpolationConfig = DEFAULT_INTERPOLATION_CONFIG;
+  if (component.has("interpolation")) {
+    const expr = component.get("interpolation");
+    const value = evaluator.evaluate(expr);
+    if (!Array.isArray(value) || value.length !== 2 || !value.every((element) => typeof element === "string")) {
+      throw createValueHasWrongTypeError(expr, value, "interpolation must be an array with 2 elements of string type");
+    }
+    interpolationConfig = InterpolationConfig.fromArray(value);
+  }
+  if (component.has("templateUrl")) {
+    const templateUrlExpr = component.get("templateUrl");
+    const templateUrl = evaluator.evaluate(templateUrlExpr);
+    if (typeof templateUrl !== "string") {
+      throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, "templateUrl must be a string");
+    }
+    try {
+      const resourceUrl = resourceLoader.resolve(templateUrl, containingFile);
+      return {
+        isInline: false,
+        interpolationConfig,
+        preserveWhitespaces,
+        templateUrl,
+        templateUrlExpression: templateUrlExpr,
+        resolvedTemplateUrl: resourceUrl
+      };
+    } catch (e) {
+      throw makeResourceNotFoundError(templateUrl, templateUrlExpr, 0);
+    }
+  } else if (component.has("template")) {
+    return {
+      isInline: true,
+      interpolationConfig,
+      preserveWhitespaces,
+      expression: component.get("template"),
+      templateUrl: containingFile,
+      resolvedTemplateUrl: containingFile
+    };
+  } else {
+    throw new FatalDiagnosticError(ErrorCode.COMPONENT_MISSING_TEMPLATE, Decorator.nodeForError(decorator), "component is missing a template");
+  }
+}
+function preloadAndParseTemplate(evaluator, resourceLoader, depTracker, preanalyzeTemplateCache, node, decorator, component, containingFile, defaultPreserveWhitespaces, options) {
+  if (component.has("templateUrl")) {
+    const templateUrlExpr = component.get("templateUrl");
+    const templateUrl = evaluator.evaluate(templateUrlExpr);
+    if (typeof templateUrl !== "string") {
+      throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, "templateUrl must be a string");
+    }
+    try {
+      const resourceUrl = resourceLoader.resolve(templateUrl, containingFile);
+      const templatePromise = resourceLoader.preload(resourceUrl, { type: "template", containingFile });
+      if (templatePromise !== void 0) {
+        return templatePromise.then(() => {
+          const templateDecl = parseTemplateDeclaration(decorator, component, containingFile, evaluator, resourceLoader, defaultPreserveWhitespaces);
+          const template = extractTemplate(node, templateDecl, evaluator, depTracker, resourceLoader, options);
+          preanalyzeTemplateCache.set(node, template);
+          return template;
+        });
+      } else {
+        return Promise.resolve(null);
+      }
+    } catch (e) {
+      throw makeResourceNotFoundError(templateUrl, templateUrlExpr, 0);
+    }
+  } else {
+    const templateDecl = parseTemplateDeclaration(decorator, component, containingFile, evaluator, resourceLoader, defaultPreserveWhitespaces);
+    const template = extractTemplate(node, templateDecl, evaluator, depTracker, resourceLoader, options);
+    preanalyzeTemplateCache.set(node, template);
+    return Promise.resolve(template);
+  }
+}
+function getTemplateRange(templateExpr) {
+  const startPos = templateExpr.getStart() + 1;
+  const { line, character } = ts23.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
+  return {
+    startPos,
+    startLine: line,
+    startCol: character,
+    endPos: templateExpr.getEnd() - 1
+  };
+}
+function makeResourceNotFoundError(file, nodeForError, resourceType) {
+  let errorText;
+  switch (resourceType) {
+    case 0:
+      errorText = `Could not find template file '${file}'.`;
+      break;
+    case 1:
+      errorText = `Could not find stylesheet file '${file}' linked from the template.`;
+      break;
+    case 2:
+      errorText = `Could not find stylesheet file '${file}'.`;
+      break;
+  }
+  return new FatalDiagnosticError(ErrorCode.COMPONENT_RESOURCE_NOT_FOUND, nodeForError, errorText);
+}
+function transformDecoratorToInlineResources(dec, component, styles, template) {
+  if (dec.name !== "Component") {
+    return dec;
+  }
+  if (!component.has("templateUrl") && !component.has("styleUrls")) {
+    return dec;
+  }
+  const metadata = new Map(component);
+  if (metadata.has("templateUrl")) {
+    metadata.delete("templateUrl");
+    metadata.set("template", ts23.factory.createStringLiteral(template.content));
+  }
+  if (metadata.has("styleUrls")) {
+    metadata.delete("styleUrls");
+    metadata.set("styles", ts23.factory.createArrayLiteralExpression(styles.map((s) => ts23.factory.createStringLiteral(s))));
+  }
+  const newMetadataFields = [];
+  for (const [name, value] of metadata.entries()) {
+    newMetadataFields.push(ts23.factory.createPropertyAssignment(name, value));
+  }
+  return __spreadProps(__spreadValues({}, dec), { args: [ts23.factory.createObjectLiteralExpression(newMetadataFields)] });
+}
+function extractComponentStyleUrls(evaluator, component) {
+  if (!component.has("styleUrls")) {
+    return [];
+  }
+  return extractStyleUrlsFromExpression(evaluator, component.get("styleUrls"));
+}
+function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
+  const styleUrls = [];
+  if (ts23.isArrayLiteralExpression(styleUrlsExpr)) {
+    for (const styleUrlExpr of styleUrlsExpr.elements) {
+      if (ts23.isSpreadElement(styleUrlExpr)) {
+        styleUrls.push(...extractStyleUrlsFromExpression(evaluator, styleUrlExpr.expression));
+      } else {
+        const styleUrl = evaluator.evaluate(styleUrlExpr);
+        if (typeof styleUrl !== "string") {
+          throw createValueHasWrongTypeError(styleUrlExpr, styleUrl, "styleUrl must be a string");
+        }
+        styleUrls.push({
+          url: styleUrl,
+          source: 2,
+          nodeForError: styleUrlExpr
+        });
+      }
+    }
+  } else {
+    const evaluatedStyleUrls = evaluator.evaluate(styleUrlsExpr);
+    if (!isStringArray(evaluatedStyleUrls)) {
+      throw createValueHasWrongTypeError(styleUrlsExpr, evaluatedStyleUrls, "styleUrls must be an array of strings");
+    }
+    for (const styleUrl of evaluatedStyleUrls) {
+      styleUrls.push({
+        url: styleUrl,
+        source: 2,
+        nodeForError: styleUrlsExpr
+      });
+    }
+  }
+  return styleUrls;
+}
+function extractStyleResources(resourceLoader, component, containingFile) {
+  const styles = /* @__PURE__ */ new Set();
+  function stringLiteralElements(array) {
+    return array.elements.filter((e) => ts23.isStringLiteralLike(e));
+  }
+  const styleUrlsExpr = component.get("styleUrls");
+  if (styleUrlsExpr !== void 0 && ts23.isArrayLiteralExpression(styleUrlsExpr)) {
+    for (const expression of stringLiteralElements(styleUrlsExpr)) {
+      try {
+        const resourceUrl = resourceLoader.resolve(expression.text, containingFile);
+        styles.add({ path: absoluteFrom(resourceUrl), expression });
+      } catch {
+      }
+    }
+  }
+  const stylesExpr = component.get("styles");
+  if (stylesExpr !== void 0 && ts23.isArrayLiteralExpression(stylesExpr)) {
+    for (const expression of stringLiteralElements(stylesExpr)) {
+      styles.add({ path: null, expression });
+    }
+  }
+  return styles;
+}
+function _extractTemplateStyleUrls(template) {
+  if (template.styleUrls === null) {
+    return [];
+  }
+  const nodeForError = getTemplateDeclarationNodeForError(template.declaration);
+  return template.styleUrls.map((url) => ({ url, source: 1, nodeForError }));
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/scope.mjs
+function scopeTemplate(scopeReader, dtsScopeReader, scopeRegistry, metaReader, node, analysis, usePoisonedData) {
+  const scope = scopeReader.getScopeForComponent(node);
+  if (analysis.meta.isStandalone && scope !== null) {
+    return null;
+  } else if (scope !== null && scope.compilation.isPoisoned && !usePoisonedData) {
+    return null;
+  }
+  if (scope !== null) {
+    return {
+      directives: scope.compilation.directives,
+      pipes: scope.compilation.pipes,
+      ngModule: scope.ngModule,
+      diagnostics: []
+    };
+  } else if (analysis.meta.isStandalone) {
+    if (analysis.imports === null) {
+      return {
+        directives: [],
+        pipes: [],
+        ngModule: null,
+        diagnostics: []
+      };
+    }
+    const diagnostics = [];
+    const directives = /* @__PURE__ */ new Map();
+    const pipes = /* @__PURE__ */ new Map();
+    for (const ref of analysis.imports.resolved) {
+      const dirMeta = metaReader.getDirectiveMetadata(ref);
+      if (dirMeta !== null) {
+        if (!dirMeta.isStandalone) {
+          diagnostics.push(makeNotStandaloneDiagnostic(scopeReader, ref, analysis.imports.raw, dirMeta.isComponent ? "component" : "directive"));
+          continue;
+        }
+        if (!directives.has(ref.node)) {
+          directives.set(ref.node, dirMeta);
+        }
+        continue;
+      }
+      const pipeMeta = metaReader.getPipeMetadata(ref);
+      if (pipeMeta !== null) {
+        if (!pipeMeta.isStandalone) {
+          diagnostics.push(makeNotStandaloneDiagnostic(scopeReader, ref, analysis.imports.raw, "pipe"));
+          continue;
+        }
       }
-    });
-    return refList;
+      const ngModuleMeta = metaReader.getNgModuleMetadata(ref);
+      if (ngModuleMeta !== null) {
+        let scope2;
+        if (ref.node.getSourceFile().isDeclarationFile) {
+          scope2 = dtsScopeReader.resolve(ref);
+        } else {
+          scope2 = scopeRegistry.getScopeOfModule(ref.node);
+        }
+        if (scope2 === null) {
+          continue;
+        }
+        if (scope2.exported.isPoisoned && !usePoisonedData) {
+          return null;
+        }
+        for (const dir of scope2.exported.directives) {
+          if (!directives.has(dir.ref.node)) {
+            directives.set(dir.ref.node, dir);
+          }
+        }
+        for (const pipe of scope2.exported.pipes) {
+          if (!pipes.has(pipe.ref.node)) {
+            pipes.set(pipe.ref.node, pipe);
+          }
+        }
+      }
+    }
+    return {
+      directives: Array.from(directives.values()),
+      pipes: Array.from(pipes.values()),
+      diagnostics,
+      ngModule: null
+    };
+  } else {
+    return {
+      directives: [],
+      pipes: [],
+      ngModule: null,
+      diagnostics: []
+    };
   }
-};
-function isNgModule(node, compilation) {
-  return !compilation.directives.some((directive) => directive.ref.node === node) && !compilation.pipes.some((pipe) => pipe.ref.node === node);
+}
+function makeNotStandaloneDiagnostic(scopeReader, ref, rawExpr, kind) {
+  const scope = scopeReader.getScopeForComponent(ref.node);
+  let relatedInformation = void 0;
+  if (scope !== null) {
+    const isExported3 = scope.exported.directives.some((exp) => exp.ref.node === ref.node) || scope.exported.pipes.some((exp) => exp.ref.node);
+    if (isExported3) {
+      relatedInformation = [makeRelatedInformation(scope.ngModule.name, `It can be imported using its NgModule '${scope.ngModule.name.text}' instead.`)];
+    } else {
+      relatedInformation = [makeRelatedInformation(scope.ngModule.name, `It's declared in the NgModule '${scope.ngModule.name.text}', but is not exported. Consider exporting it.`)];
+    }
+  } else {
+  }
+  let extraText = "";
+  if (relatedInformation === void 0) {
+    extraText = " It must be imported via an NgModule.";
+  }
+  return makeDiagnostic(ErrorCode.COMPONENT_IMPORT_NOT_STANDALONE, ref.getOriginForDiagnostics(rawExpr), `The ${kind} '${ref.node.name.text}' appears in 'imports', but is not standalone and cannot be imported directly.${extraText}`, relatedInformation);
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/component.mjs
-var EMPTY_MAP = /* @__PURE__ */ new Map();
-var EMPTY_ARRAY = [];
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/symbol.mjs
 var ComponentSymbol = class extends DirectiveSymbol {
   constructor() {
     super(...arguments);
@@ -4766,13 +5266,81 @@ var ComponentSymbol = class extends DirectiveSymbol {
     return !isArrayEqual(this.usedDirectives, previousSymbol.usedDirectives, isDirectiveUnaffected) || !isArrayEqual(this.usedPipes, previousSymbol.usedPipes, isPipeUnaffected);
   }
 };
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/util.mjs
+import ts24 from "typescript";
+function collectAnimationNames(value, animationTriggerNames) {
+  if (value instanceof Map) {
+    const name = value.get("name");
+    if (typeof name === "string") {
+      animationTriggerNames.staticTriggerNames.push(name);
+    } else {
+      animationTriggerNames.includesDynamicAnimations = true;
+    }
+  } else if (Array.isArray(value)) {
+    for (const resolvedValue of value) {
+      collectAnimationNames(resolvedValue, animationTriggerNames);
+    }
+  } else {
+    animationTriggerNames.includesDynamicAnimations = true;
+  }
+}
+function isAngularAnimationsReference(reference, symbolName) {
+  return reference.ownedByModuleGuess === "@angular/animations" && reference.debugName === symbolName;
+}
+var animationTriggerResolver = (ref, args) => {
+  const animationTriggerMethodName = "trigger";
+  if (!isAngularAnimationsReference(ref, animationTriggerMethodName)) {
+    return null;
+  }
+  const triggerNameExpression = args[0];
+  if (!triggerNameExpression) {
+    return null;
+  }
+  const factory = ts24.factory;
+  return factory.createObjectLiteralExpression([
+    factory.createPropertyAssignment(factory.createIdentifier("name"), triggerNameExpression)
+  ], true);
+};
+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();
+    return {
+      imports: [],
+      diagnostics: [error]
+    };
+  }
+  const diagnostics = [];
+  for (const ref of imports) {
+    if (Array.isArray(ref)) {
+      const { imports: childImports, diagnostics: childDiagnostics } = validateAndFlattenComponentImports(ref, expr);
+      flattened.push(...childImports);
+      diagnostics.push(...childDiagnostics);
+    } else if (ref instanceof Reference) {
+      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());
+      }
+    } else {
+      diagnostics.push(createValueHasWrongTypeError(expr, imports, `'imports' must be an array of components, directives, pipes, or NgModules`).toDiagnostic());
+    }
+  }
+  return { imports: flattened, diagnostics };
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
+var EMPTY_MAP = /* @__PURE__ */ new Map();
+var EMPTY_ARRAY = [];
 var ComponentDecoratorHandler = class {
-  constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf) {
+  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) {
     this.reflector = reflector;
     this.evaluator = evaluator;
     this.metaRegistry = metaRegistry;
     this.metaReader = metaReader;
     this.scopeReader = scopeReader;
+    this.dtsScopeReader = dtsScopeReader;
     this.scopeRegistry = scopeRegistry;
     this.typeCheckScopeRegistry = typeCheckScopeRegistry;
     this.resourceRegistry = resourceRegistry;
@@ -4797,6 +5365,11 @@ var ComponentDecoratorHandler = class {
     this.elementSchemaRegistry = new DomElementSchemaRegistry();
     this.preanalyzeTemplateCache = /* @__PURE__ */ new Map();
     this.preanalyzeStylesCache = /* @__PURE__ */ new Map();
+    this.extractTemplateOptions = {
+      enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
+      i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
+      usePoisonedData: this.usePoisonedData
+    };
     this.precedence = HandlerPrecedence.PRIMARY;
     this.name = ComponentDecoratorHandler.name;
   }
@@ -4819,7 +5392,7 @@ var ComponentDecoratorHandler = class {
     if (!this.resourceLoader.canPreload) {
       return void 0;
     }
-    const meta = this._resolveLiteral(decorator);
+    const meta = resolveLiteral(decorator, this.literalCache);
     const component = reflectObjectLiteral(meta);
     const containingFile = node.getSourceFile().fileName;
     const resolveStyleUrl = (styleUrl) => {
@@ -4830,13 +5403,13 @@ var ComponentDecoratorHandler = class {
         return void 0;
       }
     };
-    const templateAndTemplateStyleResources = this._preloadAndParseTemplate(node, decorator, component, containingFile).then((template) => {
+    const templateAndTemplateStyleResources = preloadAndParseTemplate(this.evaluator, this.resourceLoader, this.depTracker, this.preanalyzeTemplateCache, node, decorator, component, containingFile, this.defaultPreserveWhitespaces, this.extractTemplateOptions).then((template) => {
       if (template === null) {
         return void 0;
       }
       return Promise.all(template.styleUrls.map((styleUrl) => resolveStyleUrl(styleUrl))).then(() => void 0);
     });
-    const componentStyleUrls = this._extractComponentStyleUrls(component);
+    const componentStyleUrls = extractComponentStyleUrls(this.evaluator, component);
     let inlineStyles;
     if (component.has("styles")) {
       const litStyles = parseFieldArrayValue(component, "styles", this.evaluator);
@@ -4868,13 +5441,14 @@ var ComponentDecoratorHandler = class {
       return {};
     }
     const { decorator: component, metadata, inputs, outputs } = directiveResult;
-    const encapsulation = (_a = this._resolveEnumValue(component, "encapsulation", "ViewEncapsulation")) != null ? _a : ViewEncapsulation.Emulated;
-    const changeDetection = this._resolveEnumValue(component, "changeDetection", "ChangeDetectionStrategy");
+    const encapsulation = (_a = resolveEnumValue(this.evaluator, component, "encapsulation", "ViewEncapsulation")) != null ? _a : ViewEncapsulation.Emulated;
+    const changeDetection = resolveEnumValue(this.evaluator, component, "changeDetection", "ChangeDetectionStrategy");
     let animations = null;
     let animationTriggerNames = null;
     if (component.has("animations")) {
-      animations = new WrappedNodeExpr5(component.get("animations"));
-      const animationsValue = this.evaluator.evaluate(component.get("animations"));
+      const animationExpression = component.get("animations");
+      animations = new WrappedNodeExpr7(animationExpression);
+      const animationsValue = this.evaluator.evaluate(animationExpression, animationTriggerResolver);
       animationTriggerNames = { includesDynamicAnimations: false, staticTriggerNames: [] };
       collectAnimationNames(animationsValue, animationTriggerNames);
     }
@@ -4892,29 +5466,55 @@ var ComponentDecoratorHandler = class {
     if (component.has("viewProviders")) {
       const viewProviders = component.get("viewProviders");
       viewProvidersRequiringFactory = resolveProvidersRequiringFactory(viewProviders, this.reflector, this.evaluator);
-      wrappedViewProviders = new WrappedNodeExpr5(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(viewProviders) : viewProviders);
+      wrappedViewProviders = new WrappedNodeExpr7(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(viewProviders) : viewProviders);
     }
     if (component.has("providers")) {
       providersRequiringFactory = resolveProvidersRequiringFactory(component.get("providers"), this.reflector, this.evaluator);
     }
+    let imports = null;
+    if (component.has("imports") && !metadata.isStandalone) {
+      if (diagnostics === void 0) {
+        diagnostics = [];
+      }
+      diagnostics.push(makeDiagnostic(ErrorCode.COMPONENT_NOT_STANDALONE, component.get("imports"), `'imports' is only valid on a component that is standalone.`));
+    } else if (component.has("imports")) {
+      const expr = component.get("imports");
+      const imported = this.evaluator.evaluate(expr);
+      const { imports: flattened, diagnostics: importDiagnostics } = validateAndFlattenComponentImports(imported, expr);
+      imports = {
+        resolved: flattened,
+        raw: expr
+      };
+      if (importDiagnostics.length > 0) {
+        isPoisoned = true;
+        if (diagnostics === void 0) {
+          diagnostics = [];
+        }
+        diagnostics.push(...importDiagnostics);
+      }
+    }
     let template;
     if (this.preanalyzeTemplateCache.has(node)) {
       const preanalyzed = this.preanalyzeTemplateCache.get(node);
       this.preanalyzeTemplateCache.delete(node);
       template = preanalyzed;
     } else {
-      const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
-      template = this.extractTemplate(node, templateDecl);
+      const templateDecl = parseTemplateDeclaration(decorator, component, containingFile, this.evaluator, this.resourceLoader, this.defaultPreserveWhitespaces);
+      template = extractTemplate(node, templateDecl, this.evaluator, this.depTracker, this.resourceLoader, {
+        enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
+        i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
+        usePoisonedData: this.usePoisonedData
+      });
     }
     const templateResource = template.declaration.isInline ? { path: null, expression: component.get("template") } : {
       path: absoluteFrom(template.declaration.resolvedTemplateUrl),
       expression: template.sourceMapping.node
     };
     let styles = [];
-    const styleResources = this._extractStyleResources(component, containingFile);
+    const styleResources = extractStyleResources(this.resourceLoader, component, containingFile);
     const styleUrls = [
-      ...this._extractComponentStyleUrls(component),
-      ...this._extractTemplateStyleUrls(template)
+      ...extractComponentStyleUrls(this.evaluator, component),
+      ..._extractTemplateStyleUrls(template)
     ];
     for (const styleUrl of styleUrls) {
       try {
@@ -4929,7 +5529,7 @@ var ComponentDecoratorHandler = class {
           diagnostics = [];
         }
         const resourceType = styleUrl.source === 2 ? 2 : 1;
-        diagnostics.push(this.makeResourceNotFoundError(styleUrl.url, styleUrl.nodeForError, resourceType).toDiagnostic());
+        diagnostics.push(makeResourceNotFoundError(styleUrl.url, styleUrl.nodeForError, resourceType).toDiagnostic());
       }
     }
     if (encapsulation === ViewEncapsulation.ShadowDom && metadata.selector !== null) {
@@ -4974,7 +5574,7 @@ var ComponentDecoratorHandler = class {
             ngContentSelectors: template.ngContentSelectors
           },
           encapsulation,
-          interpolation: (_b = template.interpolationConfig) != null ? _b : DEFAULT_INTERPOLATION_CONFIG,
+          interpolation: (_b = template.interpolationConfig) != null ? _b : DEFAULT_INTERPOLATION_CONFIG2,
           styles,
           animations,
           viewProviders: wrappedViewProviders,
@@ -4982,7 +5582,7 @@ var ComponentDecoratorHandler = class {
           relativeContextFilePath
         }),
         typeCheckMeta: extractDirectiveTypeCheckMeta(node, inputs, this.reflector),
-        classMetadata: extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => this._transformDecoratorToInlineResources(dec, component, styles, template)),
+        classMetadata: extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorToInlineResources(dec, component, styles, template)),
         template,
         providersRequiringFactory,
         viewProvidersRequiringFactory,
@@ -4993,7 +5593,8 @@ var ComponentDecoratorHandler = class {
           template: templateResource
         },
         isPoisoned,
-        animationTriggerNames
+        animationTriggerNames,
+        imports
       },
       diagnostics
     };
@@ -5022,6 +5623,7 @@ var ComponentDecoratorHandler = class {
     }, analysis.typeCheckMeta), {
       isPoisoned: analysis.isPoisoned,
       isStructural: false,
+      isStandalone: analysis.meta.isStandalone,
       animationTriggerNames: analysis.animationTriggerNames
     }));
     this.resourceRegistry.registerResources(analysis.resources, node);
@@ -5057,7 +5659,7 @@ var ComponentDecoratorHandler = class {
     });
   }
   typeCheck(ctx, node, meta) {
-    if (this.typeCheckScopeRegistry === null || !ts21.isClassDeclaration(node)) {
+    if (this.typeCheckScopeRegistry === null || !ts25.isClassDeclaration(node)) {
       return;
     }
     if (meta.isPoisoned && !this.usePoisonedData) {
@@ -5080,23 +5682,25 @@ var ComponentDecoratorHandler = class {
     if (analysis.isPoisoned && !this.usePoisonedData) {
       return {};
     }
-    const context = node.getSourceFile();
-    const scope = this.scopeReader.getScopeForComponent(node);
-    let metadata = analysis.meta;
+    const context = getSourceFile(node);
+    const metadata = analysis.meta;
     const data = {
       directives: EMPTY_ARRAY,
       pipes: EMPTY_MAP,
       declarationListEmitMode: 0
     };
-    if (scope !== null && (!scope.compilation.isPoisoned || this.usePoisonedData)) {
+    const diagnostics = [];
+    const scope = scopeTemplate(this.scopeReader, this.dtsScopeReader, this.scopeRegistry, this.metaReader, node, analysis, this.usePoisonedData);
+    if (scope !== null) {
+      diagnostics.push(...scope.diagnostics);
       const matcher = new SelectorMatcher();
-      for (const dir of scope.compilation.directives) {
+      for (const dir of scope.directives) {
         if (dir.selector !== null) {
           matcher.addSelectables(CssSelector.parse(dir.selector), dir);
         }
       }
       const pipes = /* @__PURE__ */ new Map();
-      for (const pipe of scope.compilation.pipes) {
+      for (const pipe of scope.pipes) {
         pipes.set(pipe.name, pipe.ref);
       }
       const binder = new R3TargetBinder(matcher);
@@ -5164,7 +5768,7 @@ var ComponentDecoratorHandler = class {
         if (this.cycleHandlingStrategy === 0) {
           this.scopeRegistry.setComponentRemoteScope(node, usedDirectives.map((dir) => dir.ref), usedPipes.map((pipe) => pipe.ref));
           symbol.isRemotelyScoped = true;
-          if (this.semanticDepGraphUpdater !== null) {
+          if (this.semanticDepGraphUpdater !== null && scope.ngModule !== null) {
             const moduleSymbol = this.semanticDepGraphUpdater.getSymbol(scope.ngModule);
             if (!(moduleSymbol instanceof NgModuleSymbol)) {
               throw new Error(`AssertionError: Expected ${scope.ngModule.name} to be an NgModuleSymbol.`);
@@ -5183,12 +5787,11 @@ var ComponentDecoratorHandler = class {
         }
       }
     }
-    const diagnostics = [];
-    if (analysis.providersRequiringFactory !== null && analysis.meta.providers instanceof WrappedNodeExpr5) {
+    if (analysis.providersRequiringFactory !== null && analysis.meta.providers instanceof WrappedNodeExpr7) {
       const providerDiagnostics = getProviderDiagnostics(analysis.providersRequiringFactory, analysis.meta.providers.node, this.injectableRegistry);
       diagnostics.push(...providerDiagnostics);
     }
-    if (analysis.viewProvidersRequiringFactory !== null && analysis.meta.viewProviders instanceof WrappedNodeExpr5) {
+    if (analysis.viewProvidersRequiringFactory !== null && analysis.meta.viewProviders instanceof WrappedNodeExpr7) {
       const viewProviderDiagnostics = getProviderDiagnostics(analysis.viewProvidersRequiringFactory, analysis.meta.viewProviders.node, this.injectableRegistry);
       diagnostics.push(...viewProviderDiagnostics);
     }
@@ -5203,13 +5806,13 @@ var ComponentDecoratorHandler = class {
   }
   xi18n(ctx, node, analysis) {
     var _a;
-    ctx.updateFromTemplate(analysis.template.content, analysis.template.declaration.resolvedTemplateUrl, (_a = analysis.template.interpolationConfig) != null ? _a : DEFAULT_INTERPOLATION_CONFIG);
+    ctx.updateFromTemplate(analysis.template.content, analysis.template.declaration.resolvedTemplateUrl, (_a = analysis.template.interpolationConfig) != null ? _a : DEFAULT_INTERPOLATION_CONFIG2);
   }
   updateResources(node, analysis) {
     const containingFile = node.getSourceFile().fileName;
     const templateDecl = analysis.template.declaration;
     if (!templateDecl.isInline) {
-      analysis.template = this.extractTemplate(node, templateDecl);
+      analysis.template = extractTemplate(node, templateDecl, this.evaluator, this.depTracker, this.resourceLoader, this.extractTemplateOptions);
     }
     let styles = [];
     if (analysis.styleUrls !== null) {
@@ -5250,7 +5853,7 @@ var ComponentDecoratorHandler = class {
       content: analysis.template.content,
       sourceUrl: analysis.template.declaration.resolvedTemplateUrl,
       isInline: analysis.template.declaration.isInline,
-      inlineTemplateLiteralExpression: analysis.template.sourceMapping.type === "direct" ? new WrappedNodeExpr5(analysis.template.sourceMapping.node) : null
+      inlineTemplateLiteralExpression: analysis.template.sourceMapping.type === "direct" ? new WrappedNodeExpr7(analysis.template.sourceMapping.node) : null
     };
     const meta = __spreadValues(__spreadValues({}, analysis.meta), resolution);
     const fac = compileDeclareFactory(toFactoryMetadata(meta, FactoryTarget3.Component));
@@ -5258,389 +5861,25 @@ var ComponentDecoratorHandler = class {
     const classMetadata = analysis.classMetadata !== null ? compileDeclareClassMetadata3(analysis.classMetadata).toStmt() : null;
     return compileResults(fac, def, classMetadata, "\u0275cmp");
   }
-  _transformDecoratorToInlineResources(dec, component, styles, template) {
-    if (dec.name !== "Component") {
-      return dec;
-    }
-    if (!component.has("templateUrl") && !component.has("styleUrls")) {
-      return dec;
-    }
-    const metadata = new Map(component);
-    if (metadata.has("templateUrl")) {
-      metadata.delete("templateUrl");
-      metadata.set("template", ts21.createStringLiteral(template.content));
-    }
-    if (metadata.has("styleUrls")) {
-      metadata.delete("styleUrls");
-      metadata.set("styles", ts21.createArrayLiteral(styles.map((s) => ts21.createStringLiteral(s))));
-    }
-    const newMetadataFields = [];
-    for (const [name, value] of metadata.entries()) {
-      newMetadataFields.push(ts21.createPropertyAssignment(name, value));
-    }
-    return __spreadProps(__spreadValues({}, dec), { args: [ts21.createObjectLiteral(newMetadataFields)] });
-  }
-  _resolveLiteral(decorator) {
-    if (this.literalCache.has(decorator)) {
-      return this.literalCache.get(decorator);
-    }
-    if (decorator.args === null || decorator.args.length !== 1) {
-      throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @Component decorator`);
-    }
-    const meta = unwrapExpression(decorator.args[0]);
-    if (!ts21.isObjectLiteralExpression(meta)) {
-      throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `Decorator argument must be literal.`);
-    }
-    this.literalCache.set(decorator, meta);
-    return meta;
-  }
-  _resolveEnumValue(component, field, enumSymbolName) {
-    let resolved = null;
-    if (component.has(field)) {
-      const expr = component.get(field);
-      const value = this.evaluator.evaluate(expr);
-      if (value instanceof EnumValue && isAngularCoreReference(value.enumRef, enumSymbolName)) {
-        resolved = value.resolved;
-      } else {
-        throw createValueHasWrongTypeError(expr, value, `${field} must be a member of ${enumSymbolName} enum from @angular/core`);
-      }
-    }
-    return resolved;
-  }
-  _extractComponentStyleUrls(component) {
-    if (!component.has("styleUrls")) {
-      return [];
-    }
-    return this._extractStyleUrlsFromExpression(component.get("styleUrls"));
-  }
-  _extractStyleUrlsFromExpression(styleUrlsExpr) {
-    const styleUrls = [];
-    if (ts21.isArrayLiteralExpression(styleUrlsExpr)) {
-      for (const styleUrlExpr of styleUrlsExpr.elements) {
-        if (ts21.isSpreadElement(styleUrlExpr)) {
-          styleUrls.push(...this._extractStyleUrlsFromExpression(styleUrlExpr.expression));
-        } else {
-          const styleUrl = this.evaluator.evaluate(styleUrlExpr);
-          if (typeof styleUrl !== "string") {
-            throw createValueHasWrongTypeError(styleUrlExpr, styleUrl, "styleUrl must be a string");
-          }
-          styleUrls.push({
-            url: styleUrl,
-            source: 2,
-            nodeForError: styleUrlExpr
-          });
-        }
-      }
-    } else {
-      const evaluatedStyleUrls = this.evaluator.evaluate(styleUrlsExpr);
-      if (!isStringArray(evaluatedStyleUrls)) {
-        throw createValueHasWrongTypeError(styleUrlsExpr, evaluatedStyleUrls, "styleUrls must be an array of strings");
-      }
-      for (const styleUrl of evaluatedStyleUrls) {
-        styleUrls.push({
-          url: styleUrl,
-          source: 2,
-          nodeForError: styleUrlsExpr
-        });
-      }
-    }
-    return styleUrls;
-  }
-  _extractStyleResources(component, containingFile) {
-    const styles = /* @__PURE__ */ new Set();
-    function stringLiteralElements(array) {
-      return array.elements.filter((e) => ts21.isStringLiteralLike(e));
-    }
-    const styleUrlsExpr = component.get("styleUrls");
-    if (styleUrlsExpr !== void 0 && ts21.isArrayLiteralExpression(styleUrlsExpr)) {
-      for (const expression of stringLiteralElements(styleUrlsExpr)) {
-        try {
-          const resourceUrl = this.resourceLoader.resolve(expression.text, containingFile);
-          styles.add({ path: absoluteFrom(resourceUrl), expression });
-        } catch {
-        }
-      }
-    }
-    const stylesExpr = component.get("styles");
-    if (stylesExpr !== void 0 && ts21.isArrayLiteralExpression(stylesExpr)) {
-      for (const expression of stringLiteralElements(stylesExpr)) {
-        styles.add({ path: null, expression });
-      }
-    }
-    return styles;
-  }
-  _preloadAndParseTemplate(node, decorator, component, containingFile) {
-    if (component.has("templateUrl")) {
-      const templateUrlExpr = component.get("templateUrl");
-      const templateUrl = this.evaluator.evaluate(templateUrlExpr);
-      if (typeof templateUrl !== "string") {
-        throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, "templateUrl must be a string");
-      }
-      try {
-        const resourceUrl = this.resourceLoader.resolve(templateUrl, containingFile);
-        const templatePromise = this.resourceLoader.preload(resourceUrl, { type: "template", containingFile });
-        if (templatePromise !== void 0) {
-          return templatePromise.then(() => {
-            const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
-            const template = this.extractTemplate(node, templateDecl);
-            this.preanalyzeTemplateCache.set(node, template);
-            return template;
-          });
-        } else {
-          return Promise.resolve(null);
-        }
-      } catch (e) {
-        throw this.makeResourceNotFoundError(templateUrl, templateUrlExpr, 0);
-      }
-    } else {
-      const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
-      const template = this.extractTemplate(node, templateDecl);
-      this.preanalyzeTemplateCache.set(node, template);
-      return Promise.resolve(template);
-    }
-  }
-  extractTemplate(node, template) {
-    if (template.isInline) {
-      let sourceStr;
-      let sourceParseRange = null;
-      let templateContent;
-      let sourceMapping;
-      let escapedString = false;
-      let sourceMapUrl;
-      if (ts21.isStringLiteral(template.expression) || ts21.isNoSubstitutionTemplateLiteral(template.expression)) {
-        sourceParseRange = getTemplateRange(template.expression);
-        sourceStr = template.expression.getSourceFile().text;
-        templateContent = template.expression.text;
-        escapedString = true;
-        sourceMapping = {
-          type: "direct",
-          node: template.expression
-        };
-        sourceMapUrl = template.resolvedTemplateUrl;
-      } else {
-        const resolvedTemplate = this.evaluator.evaluate(template.expression);
-        if (typeof resolvedTemplate !== "string") {
-          throw createValueHasWrongTypeError(template.expression, resolvedTemplate, "template must be a string");
-        }
-        sourceStr = resolvedTemplate;
-        templateContent = resolvedTemplate;
-        sourceMapping = {
-          type: "indirect",
-          node: template.expression,
-          componentClass: node,
-          template: templateContent
-        };
-        sourceMapUrl = null;
-      }
-      return __spreadProps(__spreadValues({}, this._parseTemplate(template, sourceStr, sourceParseRange, escapedString, sourceMapUrl)), {
-        content: templateContent,
-        sourceMapping,
-        declaration: template
-      });
-    } else {
-      const templateContent = this.resourceLoader.load(template.resolvedTemplateUrl);
-      if (this.depTracker !== null) {
-        this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(template.resolvedTemplateUrl));
-      }
-      return __spreadProps(__spreadValues({}, this._parseTemplate(template, templateContent, null, false, template.resolvedTemplateUrl)), {
-        content: templateContent,
-        sourceMapping: {
-          type: "external",
-          componentClass: node,
-          node: template.templateUrlExpression,
-          template: templateContent,
-          templateUrl: template.resolvedTemplateUrl
-        },
-        declaration: template
-      });
-    }
-  }
-  _parseTemplate(template, sourceStr, sourceParseRange, escapedString, sourceMapUrl) {
-    const i18nNormalizeLineEndingsInICUs = escapedString || this.i18nNormalizeLineEndingsInICUs;
-    const parsedTemplate = parseTemplate(sourceStr, sourceMapUrl != null ? sourceMapUrl : "", {
-      preserveWhitespaces: template.preserveWhitespaces,
-      interpolationConfig: template.interpolationConfig,
-      range: sourceParseRange != null ? sourceParseRange : void 0,
-      escapedString,
-      enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
-      i18nNormalizeLineEndingsInICUs,
-      alwaysAttemptHtmlToR3AstConversion: this.usePoisonedData
-    });
-    const { nodes: diagNodes } = parseTemplate(sourceStr, sourceMapUrl != null ? sourceMapUrl : "", {
-      preserveWhitespaces: true,
-      preserveLineEndings: true,
-      interpolationConfig: template.interpolationConfig,
-      range: sourceParseRange != null ? sourceParseRange : void 0,
-      escapedString,
-      enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
-      i18nNormalizeLineEndingsInICUs,
-      leadingTriviaChars: [],
-      alwaysAttemptHtmlToR3AstConversion: this.usePoisonedData
-    });
-    return __spreadProps(__spreadValues({}, parsedTemplate), {
-      diagNodes,
-      file: new ParseSourceFile2(sourceStr, sourceMapUrl != null ? sourceMapUrl : "")
-    });
-  }
-  parseTemplateDeclaration(decorator, component, containingFile) {
-    let preserveWhitespaces = this.defaultPreserveWhitespaces;
-    if (component.has("preserveWhitespaces")) {
-      const expr = component.get("preserveWhitespaces");
-      const value = this.evaluator.evaluate(expr);
-      if (typeof value !== "boolean") {
-        throw createValueHasWrongTypeError(expr, value, "preserveWhitespaces must be a boolean");
-      }
-      preserveWhitespaces = value;
-    }
-    let interpolationConfig = DEFAULT_INTERPOLATION_CONFIG;
-    if (component.has("interpolation")) {
-      const expr = component.get("interpolation");
-      const value = this.evaluator.evaluate(expr);
-      if (!Array.isArray(value) || value.length !== 2 || !value.every((element) => typeof element === "string")) {
-        throw createValueHasWrongTypeError(expr, value, "interpolation must be an array with 2 elements of string type");
-      }
-      interpolationConfig = InterpolationConfig.fromArray(value);
-    }
-    if (component.has("templateUrl")) {
-      const templateUrlExpr = component.get("templateUrl");
-      const templateUrl = this.evaluator.evaluate(templateUrlExpr);
-      if (typeof templateUrl !== "string") {
-        throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, "templateUrl must be a string");
-      }
-      try {
-        const resourceUrl = this.resourceLoader.resolve(templateUrl, containingFile);
-        return {
-          isInline: false,
-          interpolationConfig,
-          preserveWhitespaces,
-          templateUrl,
-          templateUrlExpression: templateUrlExpr,
-          resolvedTemplateUrl: resourceUrl
-        };
-      } catch (e) {
-        throw this.makeResourceNotFoundError(templateUrl, templateUrlExpr, 0);
-      }
-    } else if (component.has("template")) {
-      return {
-        isInline: true,
-        interpolationConfig,
-        preserveWhitespaces,
-        expression: component.get("template"),
-        templateUrl: containingFile,
-        resolvedTemplateUrl: containingFile
-      };
-    } else {
-      throw new FatalDiagnosticError(ErrorCode.COMPONENT_MISSING_TEMPLATE, Decorator.nodeForError(decorator), "component is missing a template");
-    }
-  }
-  _resolveImportedFile(importedFile, expr, origin) {
-    if (importedFile !== "unknown") {
-      return importedFile;
-    }
-    if (!(expr instanceof ExternalExpr5)) {
-      return null;
-    }
-    return this.moduleResolver.resolveModule(expr.value.moduleName, origin.fileName);
-  }
   _checkForCyclicImport(importedFile, expr, origin) {
-    const imported = this._resolveImportedFile(importedFile, expr, origin);
+    const imported = resolveImportedFile(this.moduleResolver, importedFile, expr, origin);
     if (imported === null) {
       return null;
     }
     return this.cycleAnalyzer.wouldCreateCycle(origin, imported);
   }
   _recordSyntheticImport(importedFile, expr, origin) {
-    const imported = this._resolveImportedFile(importedFile, expr, origin);
+    const imported = resolveImportedFile(this.moduleResolver, importedFile, expr, origin);
     if (imported === null) {
       return;
     }
     this.cycleAnalyzer.recordSyntheticImport(origin, imported);
   }
-  makeResourceNotFoundError(file, nodeForError, resourceType) {
-    let errorText;
-    switch (resourceType) {
-      case 0:
-        errorText = `Could not find template file '${file}'.`;
-        break;
-      case 1:
-        errorText = `Could not find stylesheet file '${file}' linked from the template.`;
-        break;
-      case 2:
-        errorText = `Could not find stylesheet file '${file}'.`;
-        break;
-    }
-    return new FatalDiagnosticError(ErrorCode.COMPONENT_RESOURCE_NOT_FOUND, nodeForError, errorText);
-  }
-  _extractTemplateStyleUrls(template) {
-    if (template.styleUrls === null) {
-      return [];
-    }
-    const nodeForError = getTemplateDeclarationNodeForError(template.declaration);
-    return template.styleUrls.map((url) => ({ url, source: 1, nodeForError }));
-  }
 };
-function getTemplateRange(templateExpr) {
-  const startPos = templateExpr.getStart() + 1;
-  const { line, character } = ts21.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
-  return {
-    startPos,
-    startLine: line,
-    startCol: character,
-    endPos: templateExpr.getEnd() - 1
-  };
-}
-function isStringArray(resolvedValue) {
-  return Array.isArray(resolvedValue) && resolvedValue.every((elem) => typeof elem === "string");
-}
-function getTemplateDeclarationNodeForError(declaration) {
-  switch (declaration.isInline) {
-    case true:
-      return declaration.expression;
-    case false:
-      return declaration.templateUrlExpression;
-  }
-}
-function makeCyclicImportInfo(ref, type, cycle) {
-  const name = ref.debugName || "(unknown)";
-  const path = cycle.getPath().map((sf) => sf.fileName).join(" -> ");
-  const message = `The ${type} '${name}' is used in the template but importing it would create a cycle: `;
-  return makeRelatedInformation(ref.node, message + path);
-}
-function checkCustomElementSelectorForErrors(selector) {
-  if (selector.includes(".") || selector.includes("[") && selector.includes("]")) {
-    return null;
-  }
-  if (!/^[a-z]/.test(selector)) {
-    return "Selector of a ShadowDom-encapsulated component must start with a lower case letter.";
-  }
-  if (/[A-Z]/.test(selector)) {
-    return "Selector of a ShadowDom-encapsulated component must all be in lower case.";
-  }
-  if (!selector.includes("-")) {
-    return "Selector of a component that uses ViewEncapsulation.ShadowDom must contain a hyphen.";
-  }
-  return null;
-}
-function collectAnimationNames(value, animationTriggerNames) {
-  if (value instanceof Map) {
-    const name = value.get("name");
-    if (typeof name === "string") {
-      animationTriggerNames.staticTriggerNames.push(name);
-    } else {
-      animationTriggerNames.includesDynamicAnimations = true;
-    }
-  } else if (Array.isArray(value)) {
-    for (const resolvedValue of value) {
-      collectAnimationNames(resolvedValue, animationTriggerNames);
-    }
-  } else {
-    animationTriggerNames.includesDynamicAnimations = true;
-  }
-}
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/injectable.mjs
-import { compileClassMetadata as compileClassMetadata4, compileDeclareClassMetadata as compileDeclareClassMetadata4, compileDeclareInjectableFromMetadata, compileInjectable, createMayBeForwardRefExpression as createMayBeForwardRefExpression2, FactoryTarget as FactoryTarget4, LiteralExpr as LiteralExpr3, WrappedNodeExpr as WrappedNodeExpr6 } from "@angular/compiler";
-import ts22 from "typescript";
+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 ts26 from "typescript";
 var InjectableDecoratorHandler = class {
   constructor(reflector, isCore, strictCtorDeps, injectableRegistry, perf, errorOnDuplicateProv = true) {
     this.reflector = reflector;
@@ -5716,7 +5955,7 @@ var InjectableDecoratorHandler = class {
 function extractInjectableMetadata(clazz, decorator, reflector) {
   const name = clazz.name.text;
   const type = wrapTypeReference(reflector, clazz);
-  const internalType = new WrappedNodeExpr6(reflector.getInternalNameOfClass(clazz));
+  const internalType = new WrappedNodeExpr8(reflector.getInternalNameOfClass(clazz));
   const typeArgumentCount = reflector.getGenericArityOfClass(clazz) || 0;
   if (decorator.args === null) {
     throw new FatalDiagnosticError(ErrorCode.DECORATOR_NOT_CALLED, Decorator.nodeForError(decorator), "@Injectable must be called");
@@ -5731,7 +5970,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     };
   } else if (decorator.args.length === 1) {
     const metaNode = decorator.args[0];
-    if (!ts22.isObjectLiteralExpression(metaNode)) {
+    if (!ts26.isObjectLiteralExpression(metaNode)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, metaNode, `@Injectable argument must be an object literal`);
     }
     const meta = reflectObjectLiteral(metaNode);
@@ -5739,7 +5978,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     let deps = void 0;
     if ((meta.has("useClass") || meta.has("useFactory")) && meta.has("deps")) {
       const depsExpr = meta.get("deps");
-      if (!ts22.isArrayLiteralExpression(depsExpr)) {
+      if (!ts26.isArrayLiteralExpression(depsExpr)) {
         throw new FatalDiagnosticError(ErrorCode.VALUE_NOT_LITERAL, depsExpr, `@Injectable deps metadata must be an inline array`);
       }
       deps = depsExpr.elements.map((dep) => getDep(dep, reflector));
@@ -5753,7 +5992,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
       result.useClass = getProviderExpression(meta.get("useClass"), reflector);
       result.deps = deps;
     } else if (meta.has("useFactory")) {
-      result.useFactory = new WrappedNodeExpr6(meta.get("useFactory"));
+      result.useFactory = new WrappedNodeExpr8(meta.get("useFactory"));
       result.deps = deps;
     }
     return result;
@@ -5763,7 +6002,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
 }
 function getProviderExpression(expression, reflector) {
   const forwardRefValue = tryUnwrapForwardRef(expression, reflector);
-  return createMayBeForwardRefExpression2(new WrappedNodeExpr6(forwardRefValue != null ? forwardRefValue : expression), forwardRefValue !== null ? 2 : 0);
+  return createMayBeForwardRefExpression2(new WrappedNodeExpr8(forwardRefValue != null ? forwardRefValue : expression), forwardRefValue !== null ? 2 : 0);
 }
 function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, strictCtorDeps) {
   if (decorator.args === null) {
@@ -5789,7 +6028,7 @@ function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, st
 }
 function getDep(dep, reflector) {
   const meta = {
-    token: new WrappedNodeExpr6(dep),
+    token: new WrappedNodeExpr8(dep),
     attributeNameType: null,
     host: false,
     optional: false,
@@ -5804,7 +6043,7 @@ function getDep(dep, reflector) {
     switch (source.name) {
       case "Inject":
         if (token !== void 0) {
-          meta.token = new WrappedNodeExpr6(token);
+          meta.token = new WrappedNodeExpr8(token);
         }
         break;
       case "Optional":
@@ -5821,17 +6060,17 @@ function getDep(dep, reflector) {
     }
     return true;
   }
-  if (ts22.isArrayLiteralExpression(dep)) {
+  if (ts26.isArrayLiteralExpression(dep)) {
     dep.elements.forEach((el) => {
       let isDecorator = false;
-      if (ts22.isIdentifier(el)) {
+      if (ts26.isIdentifier(el)) {
         isDecorator = maybeUpdateDecorator(el, reflector);
-      } else if (ts22.isNewExpression(el) && ts22.isIdentifier(el.expression)) {
+      } else if (ts26.isNewExpression(el) && ts26.isIdentifier(el.expression)) {
         const token = el.arguments && el.arguments.length > 0 && el.arguments[0] || void 0;
         isDecorator = maybeUpdateDecorator(el.expression, reflector, token);
       }
       if (!isDecorator) {
-        meta.token = new WrappedNodeExpr6(el);
+        meta.token = new WrappedNodeExpr8(el);
       }
     });
   }
@@ -5839,8 +6078,8 @@ function getDep(dep, reflector) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/pipe.mjs
-import { compileClassMetadata as compileClassMetadata5, compileDeclareClassMetadata as compileDeclareClassMetadata5, compileDeclarePipeFromMetadata, compilePipeFromMetadata, FactoryTarget as FactoryTarget5, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
-import ts23 from "typescript";
+import { compileClassMetadata as compileClassMetadata5, compileDeclareClassMetadata as compileDeclareClassMetadata5, compileDeclarePipeFromMetadata, compilePipeFromMetadata, FactoryTarget as FactoryTarget5, WrappedNodeExpr as WrappedNodeExpr9 } from "@angular/compiler";
+import ts27 from "typescript";
 var PipeSymbol = class extends SemanticSymbol {
   constructor(decl, name) {
     super(decl);
@@ -5887,7 +6126,7 @@ var PipeDecoratorHandler = class {
     this.perf.eventCount(PerfEvent.AnalyzePipe);
     const name = clazz.name.text;
     const type = wrapTypeReference(this.reflector, clazz);
-    const internalType = new WrappedNodeExpr7(this.reflector.getInternalNameOfClass(clazz));
+    const internalType = new WrappedNodeExpr9(this.reflector.getInternalNameOfClass(clazz));
     if (decorator.args === null) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_NOT_CALLED, Decorator.nodeForError(decorator), `@Pipe must be called`);
     }
@@ -5895,7 +6134,7 @@ var PipeDecoratorHandler = class {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), "@Pipe must have exactly one argument");
     }
     const meta = unwrapExpression(decorator.args[0]);
-    if (!ts23.isObjectLiteralExpression(meta)) {
+    if (!ts27.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@Pipe must have a literal argument");
     }
     const pipe = reflectObjectLiteral(meta);
@@ -5916,6 +6155,15 @@ var PipeDecoratorHandler = class {
       }
       pure = pureValue;
     }
+    let isStandalone = false;
+    if (pipe.has("standalone")) {
+      const expr = pipe.get("standalone");
+      const resolved = this.evaluator.evaluate(expr);
+      if (typeof resolved !== "boolean") {
+        throw createValueHasWrongTypeError(expr, resolved, `standalone flag must be a boolean`);
+      }
+      isStandalone = resolved;
+    }
     return {
       analysis: {
         meta: {
@@ -5925,7 +6173,8 @@ var PipeDecoratorHandler = class {
           typeArgumentCount: this.reflector.getGenericArityOfClass(clazz) || 0,
           pipeName,
           deps: getValidConstructorDependencies(clazz, this.reflector, this.isCore),
-          pure
+          pure,
+          isStandalone
         },
         classMetadata: extractClassMetadata(clazz, this.reflector, this.isCore),
         pipeNameExpr
@@ -5937,7 +6186,13 @@ var PipeDecoratorHandler = class {
   }
   register(node, analysis) {
     const ref = new Reference(node);
-    this.metaRegistry.registerPipeMetadata({ type: MetaType.Pipe, ref, name: analysis.meta.pipeName, nameExpr: analysis.pipeNameExpr });
+    this.metaRegistry.registerPipeMetadata({
+      type: MetaType.Pipe,
+      ref,
+      name: analysis.meta.pipeName,
+      nameExpr: analysis.pipeNameExpr,
+      isStandalone: analysis.meta.isStandalone
+    });
     this.injectableRegistry.registerInjectable(node);
   }
   resolve(node) {
@@ -5963,13 +6218,13 @@ var PipeDecoratorHandler = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/references_registry.mjs
-var NoopReferencesRegistry = class {
-  add(source, ...references) {
-  }
-};
-
 export {
+  forwardRefResolver,
+  readBaseClass,
+  DynamicValue,
+  StaticInterpreter,
+  PartialEvaluator,
+  NoopReferencesRegistry,
   SemanticDepGraphUpdater,
   CompoundMetadataReader,
   DtsMetadataReader,
@@ -5978,9 +6233,6 @@ export {
   CompoundMetadataRegistry,
   InjectableClassRegistry,
   ResourceRegistry,
-  DynamicValue,
-  StaticInterpreter,
-  PartialEvaluator,
   CompilationMode,
   HandlerFlags,
   aliasTransformFactory,
@@ -5998,14 +6250,11 @@ export {
   DtsTransformRegistry,
   declarationTransformFactory,
   ivyTransformFactory,
-  forwardRefResolver,
-  readBaseClass,
   DirectiveDecoratorHandler,
   NgModuleDecoratorHandler,
   ComponentDecoratorHandler,
   InjectableDecoratorHandler,
-  PipeDecoratorHandler,
-  NoopReferencesRegistry
+  PipeDecoratorHandler
 };
 /**
  * @license
@@ -6015,4 +6264,4 @@ export {
  * found in the LICENSE file at https://angular.io/license
  */
 // Closure Compiler ignores @suppress and similar if the comment contains @license.
-//# sourceMappingURL=chunk-C44PYKVA.js.map
+//# sourceMappingURL=chunk-26T3CJIJ.js.map