@angular/compiler-cli 14.0.0-next.9 → 14.0.0-rc.0

package/bundles/{chunk-GYVY4Y2L.js → chunk-GJVJ6GH4.js}

@@ -26,19 +26,17 @@ import {
   getSourceFile,
   identifierOfNode,
   isDeclaration,
-  isDtsPath,
-  isNonDeclarationTsPath,
   makeDiagnostic,
   makeRelatedInformation,
   nodeDebugInfo,
+  nodeNameForError,
   translateExpression,
   translateStatement,
   translateType
-} from "./chunk-UMDDHI5B.js";
+} from "./chunk-JDKMNZ6O.js";
 import {
   absoluteFrom,
   absoluteFromSourceFile,
-  basename,
   relative
 } from "./chunk-T7MYRXIE.js";
 import {
@@ -143,21 +141,26 @@ function tryUnwrapForwardRef(node, reflector) {
   }
   return expr;
 }
-function forwardRefResolver(ref, args) {
-  if (!isAngularCoreReference(ref, "forwardRef") || args.length !== 1) {
-    return null;
+var forwardRefResolver = (fn, callExpr, resolve, unresolvable) => {
+  if (!isAngularCoreReference(fn, "forwardRef") || callExpr.arguments.length !== 1) {
+    return unresolvable;
   }
-  return expandForwardRef(args[0]);
-}
+  const expanded = expandForwardRef(callExpr.arguments[0]);
+  if (expanded !== null) {
+    return resolve(expanded);
+  } else {
+    return unresolvable;
+  }
+};
 function combineResolvers(resolvers) {
-  return (ref, args) => {
+  return (fn, callExpr, resolve, unresolvable) => {
     for (const resolver of resolvers) {
-      const resolved = resolver(ref, args);
-      if (resolved !== null) {
+      const resolved = resolver(fn, callExpr, resolve, unresolvable);
+      if (resolved !== unresolvable) {
         return resolved;
       }
     }
-    return null;
+    return unresolvable;
   };
 }
 function isExpressionForwardReference(expr, context, contextSource) {
@@ -303,8 +306,11 @@ var DynamicValue = class {
   static fromDynamicType(node) {
     return new DynamicValue(node, void 0, 7);
   }
+  static fromSyntheticInput(node, value) {
+    return new DynamicValue(node, value, 8);
+  }
   static fromUnknown(node) {
-    return new DynamicValue(node, void 0, 8);
+    return new DynamicValue(node, void 0, 9);
   }
   isFromDynamicInput() {
     return this.code === 0;
@@ -331,7 +337,7 @@ var DynamicValue = class {
     return this.code === 7;
   }
   isFromUnknown() {
-    return this.code === 8;
+    return this.code === 9;
   }
   accept(visitor) {
     switch (this.code) {
@@ -352,6 +358,8 @@ var DynamicValue = class {
       case 7:
         return visitor.visitDynamicType(this);
       case 8:
+        return visitor.visitSyntheticInput(this);
+      case 9:
         return visitor.visitUnknown(this);
     }
   }
@@ -538,6 +546,13 @@ function resolveKnownDeclaration(decl) {
   }
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/synthetic.mjs
+var SyntheticValue = class {
+  constructor(value) {
+    this.value = value;
+  }
+};
+
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.mjs
 function literalBinaryOp(op) {
   return { op, literal: true };
@@ -853,6 +868,8 @@ var StaticInterpreter = class {
       }
     } else if (lhs instanceof DynamicValue) {
       return DynamicValue.fromDynamicInput(node, lhs);
+    } else if (lhs instanceof SyntheticValue) {
+      return DynamicValue.fromSyntheticInput(node, lhs);
     }
     return DynamicValue.fromUnknown(node);
   }
@@ -874,31 +891,24 @@ var StaticInterpreter = class {
     if (!isFunctionOrMethodReference(lhs)) {
       return DynamicValue.fromInvalidExpressionType(node.expression, lhs);
     }
-    if (fn.body === null) {
-      let expr = null;
-      if (context.foreignFunctionResolver) {
-        expr = context.foreignFunctionResolver(lhs, node.arguments);
-      }
-      if (expr === null) {
-        return DynamicValue.fromDynamicInput(node, DynamicValue.fromExternalReference(node.expression, lhs));
-      }
-      if (expr.getSourceFile() !== node.expression.getSourceFile() && lhs.bestGuessOwningModule !== null) {
-        context = __spreadProps(__spreadValues({}, context), {
+    const resolveFfrExpr = (expr) => {
+      let contextExtension = {};
+      if (fn.body === null && expr.getSourceFile() !== node.expression.getSourceFile() && lhs.bestGuessOwningModule !== null) {
+        contextExtension = {
           absoluteModuleName: lhs.bestGuessOwningModule.specifier,
           resolutionContext: lhs.bestGuessOwningModule.resolutionContext
-        });
+        };
       }
-      return this.visitFfrExpression(expr, context);
+      return this.visitFfrExpression(expr, __spreadValues(__spreadValues({}, context), contextExtension));
+    };
+    if (fn.body === null && context.foreignFunctionResolver !== void 0) {
+      const unresolvable = DynamicValue.fromDynamicInput(node, DynamicValue.fromExternalReference(node.expression, lhs));
+      return context.foreignFunctionResolver(lhs, node, resolveFfrExpr, unresolvable);
     }
-    let res = this.visitFunctionBody(node, fn, context);
+    const res = this.visitFunctionBody(node, fn, context);
     if (res instanceof DynamicValue && context.foreignFunctionResolver !== void 0) {
-      const ffrExpr = context.foreignFunctionResolver(lhs, node.arguments);
-      if (ffrExpr !== null) {
-        const ffrRes = this.visitFfrExpression(ffrExpr, context);
-        if (!(ffrRes instanceof DynamicValue)) {
-          res = ffrRes;
-        }
-      }
+      const unresolvable = DynamicValue.fromComplexFunctionCall(node, fn);
+      return context.foreignFunctionResolver(lhs, node, resolveFfrExpr, unresolvable);
     }
     return res;
   }
@@ -1205,6 +1215,9 @@ var TraceDynamicValueVisitor = class {
     }
     return trace;
   }
+  visitSyntheticInput(value) {
+    return [makeRelatedInformation(value.node, "Unable to evaluate this expression further.")];
+  }
   visitDynamicString(value) {
     return [makeRelatedInformation(value.node, "A string value could not be determined statically.")];
   }
@@ -1662,9 +1675,39 @@ var NoopReferencesRegistry = class {
   }
 };
 
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/schema.mjs
+import { CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA } from "@angular/compiler";
+function extractSchemas(rawExpr, evaluator, context) {
+  const schemas = [];
+  const result = evaluator.evaluate(rawExpr);
+  if (!Array.isArray(result)) {
+    throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array`);
+  }
+  for (const schemaRef of result) {
+    if (!(schemaRef instanceof Reference)) {
+      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
+    }
+    const id = schemaRef.getIdentityIn(schemaRef.node.getSourceFile());
+    if (id === null || schemaRef.ownedByModuleGuess !== "@angular/core") {
+      throw createValueHasWrongTypeError(rawExpr, result, `${context}.schemas must be an array of schemas`);
+    }
+    switch (id.text) {
+      case "CUSTOM_ELEMENTS_SCHEMA":
+        schemas.push(CUSTOM_ELEMENTS_SCHEMA);
+        break;
+      case "NO_ERRORS_SCHEMA":
+        schemas.push(NO_ERRORS_SCHEMA);
+        break;
+      default:
+        throw createValueHasWrongTypeError(rawExpr, schemaRef, `'${schemaRef.debugName}' is not a valid ${context} schema`);
+    }
+  }
+  return schemas;
+}
+
 // bazel-out/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";
+import { compileClassMetadata as compileClassMetadata3, compileComponentFromMetadata, compileDeclareClassMetadata as compileDeclareClassMetadata3, compileDeclareComponentFromMetadata, CssSelector as CssSelector2, DEFAULT_INTERPOLATION_CONFIG as DEFAULT_INTERPOLATION_CONFIG2, DomElementSchemaRegistry, FactoryTarget as FactoryTarget3, makeBindingParser as makeBindingParser2, R3TargetBinder, R3TemplateDependencyKind, SelectorMatcher as SelectorMatcher2, ViewEncapsulation, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
+import ts23 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.mjs
 import ts8 from "typescript";
@@ -1899,11 +1942,12 @@ function isTypeParameterEqual(a, b) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/api.mjs
-var MetaType;
-(function(MetaType2) {
-  MetaType2[MetaType2["Pipe"] = 0] = "Pipe";
-  MetaType2[MetaType2["Directive"] = 1] = "Directive";
-})(MetaType || (MetaType = {}));
+var MetaKind;
+(function(MetaKind2) {
+  MetaKind2[MetaKind2["Directive"] = 0] = "Directive";
+  MetaKind2[MetaKind2["Pipe"] = 1] = "Pipe";
+  MetaKind2[MetaKind2["NgModule"] = 2] = "NgModule";
+})(MetaKind || (MetaKind = {}));
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/metadata/src/dts.mjs
 import ts11 from "typescript";
@@ -2006,6 +2050,19 @@ function extractReferencesFromType(checker, def, bestGuessOwningModule) {
     }
   });
 }
+function readBooleanType(type) {
+  if (!ts10.isLiteralTypeNode(type)) {
+    return null;
+  }
+  switch (type.literal.kind) {
+    case ts10.SyntaxKind.TrueKeyword:
+      return true;
+    case ts10.SyntaxKind.FalseKeyword:
+      return false;
+    default:
+      return null;
+  }
+}
 function readStringType(type) {
   if (!ts10.isLiteralTypeNode(type) || !ts10.isStringLiteral(type.literal)) {
     return null;
@@ -2167,15 +2224,19 @@ var DtsMetadataReader = class {
     }
     const [_, declarationMetadata, importMetadata, exportMetadata] = ngModuleDef.type.typeArguments;
     return {
+      kind: MetaKind.NgModule,
       ref,
       declarations: extractReferencesFromType(this.checker, declarationMetadata, ref.bestGuessOwningModule),
       exports: extractReferencesFromType(this.checker, exportMetadata, ref.bestGuessOwningModule),
       imports: extractReferencesFromType(this.checker, importMetadata, ref.bestGuessOwningModule),
       schemas: [],
-      rawDeclarations: null
+      rawDeclarations: null,
+      rawImports: null,
+      rawExports: null
     };
   }
   getDirectiveMetadata(ref) {
+    var _a;
     const clazz = ref.node;
     const def = this.reflector.getMembersOfClass(clazz).find((field) => field.isStatic && (field.name === "\u0275cmp" || field.name === "\u0275dir"));
     if (def === void 0) {
@@ -2188,10 +2249,11 @@ var DtsMetadataReader = class {
     const isStructural = !isComponent && ctorParams !== null && ctorParams.some((param) => {
       return param.typeValueReference.kind === 1 && param.typeValueReference.moduleName === "@angular/core" && param.typeValueReference.importedName === "TemplateRef";
     });
+    const isStandalone = def.type.typeArguments.length > 7 && ((_a = readBooleanType(def.type.typeArguments[7])) != null ? _a : false);
     const inputs = ClassPropertyMapping.fromMappedObject(readStringMapType(def.type.typeArguments[3]));
     const outputs = ClassPropertyMapping.fromMappedObject(readStringMapType(def.type.typeArguments[4]));
     return __spreadProps(__spreadValues({
-      type: MetaType.Directive,
+      kind: MetaKind.Directive,
       ref,
       name: clazz.name.text,
       isComponent,
@@ -2205,10 +2267,13 @@ var DtsMetadataReader = class {
       isPoisoned: false,
       isStructural,
       animationTriggerNames: null,
-      isStandalone: false
+      isStandalone,
+      imports: null,
+      schemas: null
     });
   }
   getPipeMetadata(ref) {
+    var _a;
     const def = this.reflector.getMembersOfClass(ref.node).find((field) => field.isStatic && field.name === "\u0275pipe");
     if (def === void 0) {
       return null;
@@ -2220,12 +2285,13 @@ var DtsMetadataReader = class {
       return null;
     }
     const name = type.literal.text;
+    const isStandalone = def.type.typeArguments.length > 2 && ((_a = readBooleanType(def.type.typeArguments[2])) != null ? _a : false);
     return {
-      type: MetaType.Pipe,
+      kind: MetaKind.Pipe,
       ref,
       name,
       nameExpr: null,
-      isStandalone: false
+      isStandalone
     };
   }
 };
@@ -2435,441 +2501,583 @@ var ResourceRegistry = class {
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/api.mjs
-var CompilationMode;
-(function(CompilationMode2) {
-  CompilationMode2[CompilationMode2["FULL"] = 0] = "FULL";
-  CompilationMode2[CompilationMode2["PARTIAL"] = 1] = "PARTIAL";
-})(CompilationMode || (CompilationMode = {}));
-var HandlerPrecedence;
-(function(HandlerPrecedence2) {
-  HandlerPrecedence2[HandlerPrecedence2["PRIMARY"] = 0] = "PRIMARY";
-  HandlerPrecedence2[HandlerPrecedence2["SHARED"] = 1] = "SHARED";
-  HandlerPrecedence2[HandlerPrecedence2["WEAK"] = 2] = "WEAK";
-})(HandlerPrecedence || (HandlerPrecedence = {}));
-var HandlerFlags;
-(function(HandlerFlags2) {
-  HandlerFlags2[HandlerFlags2["NONE"] = 0] = "NONE";
-  HandlerFlags2[HandlerFlags2["FULL_INHERITANCE"] = 1] = "FULL_INHERITANCE";
-})(HandlerFlags || (HandlerFlags = {}));
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/alias.mjs
-import ts12 from "typescript";
-function aliasTransformFactory(exportStatements) {
-  return (context) => {
-    return (file) => {
-      if (ts12.isBundle(file) || !exportStatements.has(file.fileName)) {
-        return file;
-      }
-      const statements = [...file.statements];
-      exportStatements.get(file.fileName).forEach(([moduleName, symbolName], aliasName) => {
-        const stmt = ts12.factory.createExportDeclaration(void 0, void 0, false, ts12.createNamedExports([ts12.factory.createExportSpecifier(false, symbolName, aliasName)]), ts12.factory.createStringLiteral(moduleName));
-        statements.push(stmt);
-      });
-      return ts12.factory.updateSourceFile(file, statements);
-    };
-  };
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
-import ts16 from "typescript";
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/adapter.mjs
-import ts13 from "typescript";
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/api.mjs
+var ComponentScopeKind;
+(function(ComponentScopeKind2) {
+  ComponentScopeKind2[ComponentScopeKind2["NgModule"] = 0] = "NgModule";
+  ComponentScopeKind2[ComponentScopeKind2["Standalone"] = 1] = "Standalone";
+})(ComponentScopeKind || (ComponentScopeKind = {}));
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/expando.mjs
-var NgExtension = Symbol("NgExtension");
-function isExtended(sf) {
-  return sf[NgExtension] !== void 0;
-}
-function sfExtensionData(sf) {
-  const extSf = sf;
-  if (extSf[NgExtension] !== void 0) {
-    return extSf[NgExtension];
-  }
-  const extension = {
-    isTopLevelShim: false,
-    fileShim: null,
-    originalReferencedFiles: null,
-    taggedReferenceFiles: null
-  };
-  extSf[NgExtension] = extension;
-  return extension;
-}
-function isFileShimSourceFile(sf) {
-  return isExtended(sf) && sf[NgExtension].fileShim !== null;
-}
-function isShim(sf) {
-  return isExtended(sf) && (sf[NgExtension].fileShim !== null || sf[NgExtension].isTopLevelShim);
-}
-function copyFileShimData(from, to) {
-  if (!isFileShimSourceFile(from)) {
-    return;
-  }
-  sfExtensionData(to).fileShim = sfExtensionData(from).fileShim;
-}
-function untagAllTsFiles(program) {
-  for (const sf of program.getSourceFiles()) {
-    untagTsFile(sf);
-  }
-}
-function retagAllTsFiles(program) {
-  for (const sf of program.getSourceFiles()) {
-    retagTsFile(sf);
-  }
-}
-function untagTsFile(sf) {
-  if (sf.isDeclarationFile || !isExtended(sf)) {
-    return;
-  }
-  const ext = sfExtensionData(sf);
-  if (ext.originalReferencedFiles !== null) {
-    sf.referencedFiles = ext.originalReferencedFiles;
-  }
-}
-function retagTsFile(sf) {
-  if (sf.isDeclarationFile || !isExtended(sf)) {
-    return;
-  }
-  const ext = sfExtensionData(sf);
-  if (ext.taggedReferenceFiles !== null) {
-    sf.referencedFiles = ext.taggedReferenceFiles;
-  }
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/util.mjs
-var TS_EXTENSIONS = /\.tsx?$/i;
-function makeShimFileName(fileName, suffix) {
-  return absoluteFrom(fileName.replace(TS_EXTENSIONS, suffix));
-}
-function generatedModuleName(originalModuleName, originalFileName, genSuffix) {
-  let moduleName;
-  if (originalFileName.endsWith("/index.ts")) {
-    moduleName = originalModuleName + "/index" + genSuffix;
-  } else {
-    moduleName = originalModuleName + genSuffix;
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/component_scope.mjs
+var CompoundComponentScopeReader = class {
+  constructor(readers) {
+    this.readers = readers;
   }
-  return moduleName;
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/adapter.mjs
-var ShimAdapter = class {
-  constructor(delegate, tsRootFiles, topLevelGenerators, perFileGenerators, oldProgram) {
-    this.delegate = delegate;
-    this.shims = /* @__PURE__ */ new Map();
-    this.priorShims = /* @__PURE__ */ new Map();
-    this.notShims = /* @__PURE__ */ new Set();
-    this.generators = [];
-    this.ignoreForEmit = /* @__PURE__ */ new Set();
-    this.extensionPrefixes = [];
-    for (const gen of perFileGenerators) {
-      const pattern = `^(.*)\\.${gen.extensionPrefix}\\.ts$`;
-      const regexp = new RegExp(pattern, "i");
-      this.generators.push({
-        generator: gen,
-        test: regexp,
-        suffix: `.${gen.extensionPrefix}.ts`
-      });
-      this.extensionPrefixes.push(gen.extensionPrefix);
-    }
-    const extraInputFiles = [];
-    for (const gen of topLevelGenerators) {
-      const sf = gen.makeTopLevelShim();
-      sfExtensionData(sf).isTopLevelShim = true;
-      if (!gen.shouldEmit) {
-        this.ignoreForEmit.add(sf);
-      }
-      const fileName = absoluteFromSourceFile(sf);
-      this.shims.set(fileName, sf);
-      extraInputFiles.push(fileName);
-    }
-    for (const rootFile of tsRootFiles) {
-      for (const gen of this.generators) {
-        extraInputFiles.push(makeShimFileName(rootFile, gen.suffix));
+  getScopeForComponent(clazz) {
+    for (const reader of this.readers) {
+      const meta = reader.getScopeForComponent(clazz);
+      if (meta !== null) {
+        return meta;
       }
     }
-    this.extraInputFiles = extraInputFiles;
-    if (oldProgram !== null) {
-      for (const oldSf of oldProgram.getSourceFiles()) {
-        if (oldSf.isDeclarationFile || !isFileShimSourceFile(oldSf)) {
-          continue;
-        }
-        this.priorShims.set(absoluteFromSourceFile(oldSf), oldSf);
+    return null;
+  }
+  getRemoteScope(clazz) {
+    for (const reader of this.readers) {
+      const remoteScope = reader.getRemoteScope(clazz);
+      if (remoteScope !== null) {
+        return remoteScope;
       }
     }
+    return null;
   }
-  maybeGenerate(fileName) {
-    if (this.notShims.has(fileName)) {
-      return null;
-    } else if (this.shims.has(fileName)) {
-      return this.shims.get(fileName);
+};
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/dependency.mjs
+var MetadataDtsModuleScopeResolver = class {
+  constructor(dtsMetaReader, aliasingHost) {
+    this.dtsMetaReader = dtsMetaReader;
+    this.aliasingHost = aliasingHost;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  resolve(ref) {
+    const clazz = ref.node;
+    const sourceFile = clazz.getSourceFile();
+    if (!sourceFile.isDeclarationFile) {
+      throw new Error(`Debug error: DtsModuleScopeResolver.read(${ref.debugName} from ${sourceFile.fileName}), but not a .d.ts file`);
+    }
+    if (this.cache.has(clazz)) {
+      return this.cache.get(clazz);
     }
-    if (isDtsPath(fileName)) {
-      this.notShims.add(fileName);
+    const dependencies = [];
+    const meta = this.dtsMetaReader.getNgModuleMetadata(ref);
+    if (meta === null) {
+      this.cache.set(clazz, null);
       return null;
     }
-    for (const record of this.generators) {
-      const match = record.test.exec(fileName);
-      if (match === null) {
+    const declarations = /* @__PURE__ */ new Set();
+    for (const declRef of meta.declarations) {
+      declarations.add(declRef.node);
+    }
+    for (const exportRef of meta.exports) {
+      const directive = this.dtsMetaReader.getDirectiveMetadata(exportRef);
+      if (directive !== null) {
+        const isReExport = !declarations.has(exportRef.node);
+        dependencies.push(this.maybeAlias(directive, sourceFile, isReExport));
         continue;
       }
-      const prefix = match[1];
-      let baseFileName = absoluteFrom(prefix + ".ts");
-      if (!this.delegate.fileExists(baseFileName)) {
-        baseFileName = absoluteFrom(prefix + ".tsx");
-        if (!this.delegate.fileExists(baseFileName)) {
-          return void 0;
-        }
+      const pipe = this.dtsMetaReader.getPipeMetadata(exportRef);
+      if (pipe !== null) {
+        const isReExport = !declarations.has(exportRef.node);
+        dependencies.push(this.maybeAlias(pipe, sourceFile, isReExport));
+        continue;
       }
-      const inputFile = this.delegate.getSourceFile(baseFileName, ts13.ScriptTarget.Latest);
-      if (inputFile === void 0 || isShim(inputFile)) {
-        return void 0;
+      const exportScope2 = this.resolve(exportRef);
+      if (exportScope2 !== null) {
+        if (this.aliasingHost === null) {
+          dependencies.push(...exportScope2.exported.dependencies);
+        } else {
+          for (const dep of exportScope2.exported.dependencies) {
+            dependencies.push(this.maybeAlias(dep, sourceFile, true));
+          }
+        }
       }
-      return this.generateSpecific(fileName, record.generator, inputFile);
+      continue;
     }
-    this.notShims.add(fileName);
-    return null;
+    const exportScope = {
+      exported: {
+        dependencies,
+        isPoisoned: false
+      }
+    };
+    this.cache.set(clazz, exportScope);
+    return exportScope;
   }
-  generateSpecific(fileName, generator, inputFile) {
-    let priorShimSf = null;
-    if (this.priorShims.has(fileName)) {
-      priorShimSf = this.priorShims.get(fileName);
-      this.priorShims.delete(fileName);
+  maybeAlias(dirOrPipe, maybeAliasFrom, isReExport) {
+    const ref = dirOrPipe.ref;
+    if (this.aliasingHost === null || ref.node.getSourceFile() === maybeAliasFrom) {
+      return dirOrPipe;
     }
-    const shimSf = generator.generateShimForFile(inputFile, fileName, priorShimSf);
-    sfExtensionData(shimSf).fileShim = {
-      extension: generator.extensionPrefix,
-      generatedFrom: absoluteFromSourceFile(inputFile)
-    };
-    if (!generator.shouldEmit) {
-      this.ignoreForEmit.add(shimSf);
+    const alias = this.aliasingHost.getAliasIn(ref.node, maybeAliasFrom, isReExport);
+    if (alias === null) {
+      return dirOrPipe;
     }
-    this.shims.set(fileName, shimSf);
-    return shimSf;
+    return __spreadProps(__spreadValues({}, dirOrPipe), {
+      ref: ref.cloneWithAlias(alias)
+    });
   }
 };
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/factory_generator.mjs
-import ts14 from "typescript";
-var TS_DTS_SUFFIX = /(\.d)?\.ts$/;
-var STRIP_NG_FACTORY = /(.*)NgFactory$/;
-var FactoryGenerator = class {
-  constructor() {
-    this.sourceInfo = /* @__PURE__ */ new Map();
-    this.sourceToFactorySymbols = /* @__PURE__ */ new Map();
-    this.shouldEmit = true;
-    this.extensionPrefix = "ngfactory";
-  }
-  generateShimForFile(sf, genFilePath) {
-    const absoluteSfPath = absoluteFromSourceFile(sf);
-    const relativePathToSource = "./" + basename(sf.fileName).replace(TS_DTS_SUFFIX, "");
-    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) {
-      sourceText = leadingComment + "\n\n";
-    }
-    if (symbolNames.length > 0) {
-      const varLines = symbolNames.map((name) => `export const ${name}NgFactory: i0.\u0275NgModuleFactory<any> = new i0.\u0275NgModuleFactory(${name});`);
-      sourceText += [
-        `import * as i0 from '@angular/core';`,
-        `import {${symbolNames.join(", ")}} from '${relativePathToSource}';`,
-        ...varLines
-      ].join("\n");
-    }
-    sourceText += "\nexport const \u0275NonEmptyModule = true;";
-    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");
-    }
-    const moduleSymbols = /* @__PURE__ */ new Map();
-    this.sourceToFactorySymbols.set(absoluteSfPath, moduleSymbols);
-    this.sourceInfo.set(genFilePath, {
-      sourceFilePath: absoluteSfPath,
-      moduleSymbols
-    });
-    return genFile;
-  }
-  track(sf, moduleInfo) {
-    if (this.sourceToFactorySymbols.has(sf.fileName)) {
-      this.sourceToFactorySymbols.get(sf.fileName).set(moduleInfo.name, moduleInfo);
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/local.mjs
+import { ExternalExpr as ExternalExpr3 } from "@angular/compiler";
+import ts12 from "typescript";
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/util.mjs
+function getDiagnosticNode(ref, rawExpr) {
+  return rawExpr !== null ? ref.getOriginForDiagnostics(rawExpr) : ref.node.name;
+}
+function makeNotStandaloneDiagnostic(scopeReader, ref, rawExpr, kind) {
+  const scope = scopeReader.getScopeForComponent(ref.node);
+  let message = `The ${kind} '${ref.node.name.text}' appears in 'imports', but is not standalone and cannot be imported directly.`;
+  let relatedInformation = void 0;
+  if (scope !== null && scope.kind === ComponentScopeKind.NgModule) {
+    const isExported = scope.exported.dependencies.some((dep) => dep.ref.node === ref.node);
+    if (isExported) {
+      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 {
   }
-};
-function isExported(decl) {
-  return decl.modifiers !== void 0 && decl.modifiers.some((mod) => mod.kind == ts14.SyntaxKind.ExportKeyword);
+  if (relatedInformation === void 0) {
+    message += " It must be imported via an NgModule.";
+  }
+  return makeDiagnostic(ErrorCode.COMPONENT_IMPORT_NOT_STANDALONE, getDiagnosticNode(ref, rawExpr), message, relatedInformation);
 }
-function generatedFactoryTransform(factoryMap, importRewriter) {
-  return (context) => {
-    return (file) => {
-      return transformFactorySourceFile(factoryMap, context, importRewriter, file);
-    };
-  };
+function makeUnknownComponentImportDiagnostic(ref, rawExpr) {
+  return makeDiagnostic(ErrorCode.COMPONENT_UNKNOWN_IMPORT, getDiagnosticNode(ref, rawExpr), `Component imports must be standalone components, directives, pipes, or must be NgModules.`);
 }
-function transformFactorySourceFile(factoryMap, context, importRewriter, file) {
-  if (!factoryMap.has(file.fileName)) {
-    return file;
-  }
-  const { moduleSymbols, sourceFilePath } = factoryMap.get(file.fileName);
-  const transformedStatements = [];
-  let nonEmptyExport = null;
-  const coreImportIdentifiers = /* @__PURE__ */ new Set();
-  for (const stmt of file.statements) {
-    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(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);
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/local.mjs
+var LocalModuleScopeRegistry = class {
+  constructor(localReader, fullReader, dependencyScopeReader, refEmitter, aliasingHost) {
+    this.localReader = localReader;
+    this.fullReader = fullReader;
+    this.dependencyScopeReader = dependencyScopeReader;
+    this.refEmitter = refEmitter;
+    this.aliasingHost = aliasingHost;
+    this.sealed = false;
+    this.declarationToModule = /* @__PURE__ */ new Map();
+    this.duplicateDeclarations = /* @__PURE__ */ new Map();
+    this.moduleToRef = /* @__PURE__ */ new Map();
+    this.cache = /* @__PURE__ */ new Map();
+    this.remoteScoping = /* @__PURE__ */ new Map();
+    this.scopeErrors = /* @__PURE__ */ new Map();
+    this.modulesWithStructuralErrors = /* @__PURE__ */ new Set();
+  }
+  registerNgModuleMetadata(data) {
+    this.assertCollecting();
+    const ngModule = data.ref.node;
+    this.moduleToRef.set(data.ref.node, data.ref);
+    for (const decl of data.declarations) {
+      this.registerDeclarationOfModule(ngModule, decl, data.rawDeclarations);
+    }
+  }
+  registerDirectiveMetadata(directive) {
+  }
+  registerPipeMetadata(pipe) {
+  }
+  getScopeForComponent(clazz) {
+    const scope = !this.declarationToModule.has(clazz) ? null : this.getScopeOfModule(this.declarationToModule.get(clazz).ngModule);
+    return scope;
+  }
+  getDuplicateDeclarations(node) {
+    if (!this.duplicateDeclarations.has(node)) {
+      return null;
+    }
+    return Array.from(this.duplicateDeclarations.get(node).values());
+  }
+  getScopeOfModule(clazz) {
+    return this.moduleToRef.has(clazz) ? this.getScopeOfModuleReference(this.moduleToRef.get(clazz)) : null;
+  }
+  getDiagnosticsOfModule(clazz) {
+    this.getScopeOfModule(clazz);
+    if (this.scopeErrors.has(clazz)) {
+      return this.scopeErrors.get(clazz);
+    } else {
+      return null;
+    }
+  }
+  registerDeclarationOfModule(ngModule, decl, rawDeclarations) {
+    const declData = {
+      ngModule,
+      ref: decl,
+      rawDeclarations
+    };
+    if (this.duplicateDeclarations.has(decl.node)) {
+      this.duplicateDeclarations.get(decl.node).set(ngModule, declData);
+    } else if (this.declarationToModule.has(decl.node) && this.declarationToModule.get(decl.node).ngModule !== ngModule) {
+      const duplicateDeclMap = /* @__PURE__ */ new Map();
+      const firstDeclData = this.declarationToModule.get(decl.node);
+      this.modulesWithStructuralErrors.add(firstDeclData.ngModule);
+      this.modulesWithStructuralErrors.add(ngModule);
+      duplicateDeclMap.set(firstDeclData.ngModule, firstDeclData);
+      duplicateDeclMap.set(ngModule, declData);
+      this.duplicateDeclarations.set(decl.node, duplicateDeclMap);
+      this.declarationToModule.delete(decl.node);
+    } else {
+      this.declarationToModule.set(decl.node, declData);
+    }
+  }
+  getScopeOfModuleReference(ref) {
+    if (this.cache.has(ref.node)) {
+      return this.cache.get(ref.node);
+    }
+    this.sealed = true;
+    const ngModule = this.localReader.getNgModuleMetadata(ref);
+    if (ngModule === null) {
+      this.cache.set(ref.node, null);
+      return null;
+    }
+    const diagnostics = [];
+    const compilationDirectives = /* @__PURE__ */ new Map();
+    const compilationPipes = /* @__PURE__ */ new Map();
+    const declared = /* @__PURE__ */ new Set();
+    const exportDirectives = /* @__PURE__ */ new Map();
+    const exportPipes = /* @__PURE__ */ new Map();
+    let isPoisoned = false;
+    if (this.modulesWithStructuralErrors.has(ngModule.ref.node)) {
+      isPoisoned = true;
+    }
+    for (const decl of ngModule.imports) {
+      const importScope = this.getExportedScope(decl, diagnostics, ref.node, "import");
+      if (importScope !== null) {
+        if (importScope === "invalid" || importScope.exported.isPoisoned) {
+          diagnostics.push(invalidTransitiveNgModuleRef(decl, ngModule.rawImports, "import"));
+          isPoisoned = true;
+          if (importScope === "invalid") {
+            continue;
+          }
         }
+        for (const dep of importScope.exported.dependencies) {
+          if (dep.kind === MetaKind.Directive) {
+            compilationDirectives.set(dep.ref.node, dep);
+          } else if (dep.kind === MetaKind.Pipe) {
+            compilationPipes.set(dep.ref.node, dep);
+          }
+        }
+        continue;
+      }
+      const directive = this.fullReader.getDirectiveMetadata(decl);
+      if (directive !== null) {
+        if (directive.isStandalone) {
+          compilationDirectives.set(directive.ref.node, directive);
+        } else {
+          diagnostics.push(makeNotStandaloneDiagnostic(this, decl, ngModule.rawImports, directive.isComponent ? "component" : "directive"));
+          isPoisoned = true;
+        }
+        continue;
+      }
+      const pipe = this.fullReader.getPipeMetadata(decl);
+      if (pipe !== null) {
+        if (pipe.isStandalone) {
+          compilationPipes.set(pipe.ref.node, pipe);
+        } else {
+          diagnostics.push(makeNotStandaloneDiagnostic(this, decl, ngModule.rawImports, "pipe"));
+          isPoisoned = true;
+        }
+        continue;
+      }
+      diagnostics.push(invalidRef(decl, ngModule.rawImports, "import"));
+      isPoisoned = true;
+    }
+    for (const decl of ngModule.declarations) {
+      const directive = this.localReader.getDirectiveMetadata(decl);
+      const pipe = this.localReader.getPipeMetadata(decl);
+      if (directive !== null) {
+        if (directive.isStandalone) {
+          const refType = directive.isComponent ? "Component" : "Directive";
+          diagnostics.push(makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_IS_STANDALONE, decl.getOriginForDiagnostics(ngModule.rawDeclarations), `${refType} ${decl.node.name.text} is standalone, and cannot be declared in an NgModule. Did you mean to import it instead?`));
+          isPoisoned = true;
+          continue;
+        }
+        compilationDirectives.set(decl.node, __spreadProps(__spreadValues({}, directive), { ref: decl }));
+        if (directive.isPoisoned) {
+          isPoisoned = true;
+        }
+      } else if (pipe !== null) {
+        if (pipe.isStandalone) {
+          diagnostics.push(makeDiagnostic(ErrorCode.NGMODULE_DECLARATION_IS_STANDALONE, decl.getOriginForDiagnostics(ngModule.rawDeclarations), `Pipe ${decl.node.name.text} is standalone, and cannot be declared in an NgModule. Did you mean to import it instead?`));
+          isPoisoned = true;
+          continue;
+        }
+        compilationPipes.set(decl.node, __spreadProps(__spreadValues({}, pipe), { ref: decl }));
       } else {
-        transformedStatements.push(stmt);
+        const errorNode = decl.getOriginForDiagnostics(ngModule.rawDeclarations);
+        diagnostics.push(makeDiagnostic(ErrorCode.NGMODULE_INVALID_DECLARATION, errorNode, `The class '${decl.node.name.text}' is listed in the declarations of the NgModule '${ngModule.ref.node.name.text}', but is not a directive, a component, or a pipe. Either remove it from the NgModule's declarations, or add an appropriate Angular decorator.`, [makeRelatedInformation(decl.node.name, `'${decl.node.name.text}' is declared here.`)]));
+        isPoisoned = true;
+        continue;
       }
-    } else if (ts14.isVariableStatement(stmt) && stmt.declarationList.declarations.length === 1) {
-      const decl = stmt.declarationList.declarations[0];
-      if (ts14.isIdentifier(decl.name)) {
-        if (decl.name.text === "\u0275NonEmptyModule") {
-          nonEmptyExport = stmt;
+      declared.add(decl.node);
+    }
+    for (const decl of ngModule.exports) {
+      const exportScope = this.getExportedScope(decl, diagnostics, ref.node, "export");
+      if (exportScope === "invalid" || exportScope !== null && exportScope.exported.isPoisoned) {
+        diagnostics.push(invalidTransitiveNgModuleRef(decl, ngModule.rawExports, "export"));
+        isPoisoned = true;
+        if (exportScope === "invalid") {
           continue;
         }
-        const match = STRIP_NG_FACTORY.exec(decl.name.text);
-        const module = match ? moduleSymbols.get(match[1]) : null;
-        if (module) {
-          transformedStatements.push(updateInitializers(stmt, (init) => init ? wrapInNoSideEffects(init) : void 0));
+      } else if (exportScope !== null) {
+        for (const dep of exportScope.exported.dependencies) {
+          if (dep.kind == MetaKind.Directive) {
+            exportDirectives.set(dep.ref.node, dep);
+          } else if (dep.kind === MetaKind.Pipe) {
+            exportPipes.set(dep.ref.node, dep);
+          }
         }
+      } else if (compilationDirectives.has(decl.node)) {
+        const directive = compilationDirectives.get(decl.node);
+        exportDirectives.set(decl.node, directive);
+      } else if (compilationPipes.has(decl.node)) {
+        const pipe = compilationPipes.get(decl.node);
+        exportPipes.set(decl.node, pipe);
       } else {
-        transformedStatements.push(stmt);
+        const dirMeta = this.fullReader.getDirectiveMetadata(decl);
+        const pipeMeta = this.fullReader.getPipeMetadata(decl);
+        if (dirMeta !== null || pipeMeta !== null) {
+          const isStandalone = dirMeta !== null ? dirMeta.isStandalone : pipeMeta.isStandalone;
+          diagnostics.push(invalidReexport(decl, ngModule.rawExports, isStandalone));
+        } else {
+          diagnostics.push(invalidRef(decl, ngModule.rawExports, "export"));
+        }
+        isPoisoned = true;
+        continue;
       }
-    } else {
-      transformedStatements.push(stmt);
     }
+    const exported = {
+      dependencies: [...exportDirectives.values(), ...exportPipes.values()],
+      isPoisoned
+    };
+    const reexports = this.getReexports(ngModule, ref, declared, exported.dependencies, diagnostics);
+    const scope = {
+      kind: ComponentScopeKind.NgModule,
+      ngModule: ngModule.ref.node,
+      compilation: {
+        dependencies: [...compilationDirectives.values(), ...compilationPipes.values()],
+        isPoisoned
+      },
+      exported,
+      reexports,
+      schemas: ngModule.schemas
+    };
+    if (diagnostics.length > 0) {
+      this.scopeErrors.set(ref.node, diagnostics);
+      this.modulesWithStructuralErrors.add(ref.node);
+    }
+    this.cache.set(ref.node, scope);
+    return scope;
   }
-  if (!transformedStatements.some(ts14.isVariableStatement) && nonEmptyExport !== null) {
-    transformedStatements.push(nonEmptyExport);
+  getRemoteScope(node) {
+    return this.remoteScoping.has(node) ? this.remoteScoping.get(node) : null;
   }
-  file = ts14.factory.updateSourceFile(file, transformedStatements);
-  if (coreImportIdentifiers.size > 0) {
-    const visit2 = (node) => {
-      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 = ts14.factory.updatePropertyAccessExpression(node, node.expression, ts14.factory.createIdentifier(rewrittenSymbol));
-          node = updated;
+  setComponentRemoteScope(node, directives, pipes) {
+    this.remoteScoping.set(node, { directives, pipes });
+  }
+  getExportedScope(ref, diagnostics, ownerForErrors, type) {
+    if (ref.node.getSourceFile().isDeclarationFile) {
+      if (!ts12.isClassDeclaration(ref.node)) {
+        const code = type === "import" ? ErrorCode.NGMODULE_INVALID_IMPORT : ErrorCode.NGMODULE_INVALID_EXPORT;
+        diagnostics.push(makeDiagnostic(code, identifierOfNode(ref.node) || ref.node, `Appears in the NgModule.${type}s of ${nodeNameForError(ownerForErrors)}, but could not be resolved to an NgModule`));
+        return "invalid";
+      }
+      return this.dependencyScopeReader.resolve(ref);
+    } else {
+      return this.getScopeOfModuleReference(ref);
+    }
+  }
+  getReexports(ngModule, ref, declared, exported, diagnostics) {
+    let reexports = null;
+    const sourceFile = ref.node.getSourceFile();
+    if (this.aliasingHost === null) {
+      return null;
+    }
+    reexports = [];
+    const reexportMap = /* @__PURE__ */ new Map();
+    const ngModuleRef = ref;
+    const addReexport = (exportRef) => {
+      if (exportRef.node.getSourceFile() === sourceFile) {
+        return;
+      }
+      const isReExport = !declared.has(exportRef.node);
+      const exportName = this.aliasingHost.maybeAliasSymbolAs(exportRef, sourceFile, ngModule.ref.node.name.text, isReExport);
+      if (exportName === null) {
+        return;
+      }
+      if (!reexportMap.has(exportName)) {
+        if (exportRef.alias && exportRef.alias instanceof ExternalExpr3) {
+          reexports.push({
+            fromModule: exportRef.alias.value.moduleName,
+            symbolName: exportRef.alias.value.name,
+            asAlias: exportName
+          });
+        } else {
+          const emittedRef = this.refEmitter.emit(exportRef.cloneWithNoIdentifiers(), sourceFile);
+          assertSuccessfulReferenceEmit(emittedRef, ngModuleRef.node.name, "class");
+          const expr = emittedRef.expression;
+          if (!(expr instanceof ExternalExpr3) || expr.value.moduleName === null || expr.value.name === null) {
+            throw new Error("Expected ExternalExpr");
+          }
+          reexports.push({
+            fromModule: expr.value.moduleName,
+            symbolName: expr.value.name,
+            asAlias: exportName
+          });
         }
+        reexportMap.set(exportName, exportRef);
+      } else {
+        const prevRef = reexportMap.get(exportName);
+        diagnostics.push(reexportCollision(ngModuleRef.node, prevRef, exportRef));
       }
-      return node;
     };
-    file = visit2(file);
-  }
-  return file;
-}
-function getFileoverviewComment(sourceFile) {
-  const text = sourceFile.getFullText();
-  const trivia = text.substring(0, sourceFile.getStart());
-  const leadingComments = ts14.getLeadingCommentRanges(trivia, 0);
-  if (!leadingComments || leadingComments.length === 0) {
-    return null;
+    for (const { ref: ref2 } of exported) {
+      addReexport(ref2);
+    }
+    return reexports;
   }
-  const comment = leadingComments[0];
-  if (comment.kind !== ts14.SyntaxKind.MultiLineCommentTrivia) {
-    return null;
+  assertCollecting() {
+    if (this.sealed) {
+      throw new Error(`Assertion: LocalModuleScopeRegistry is not COLLECTING`);
+    }
   }
-  if (text.substring(comment.end, comment.end + 2) !== "\n\n") {
-    return null;
+};
+function invalidRef(decl, rawExpr, type) {
+  const code = type === "import" ? ErrorCode.NGMODULE_INVALID_IMPORT : ErrorCode.NGMODULE_INVALID_EXPORT;
+  const resolveTarget = type === "import" ? "NgModule" : "NgModule, Component, Directive, or Pipe";
+  const message = `'${decl.node.name.text}' does not appear to be an ${resolveTarget} class.`;
+  const library = decl.ownedByModuleGuess !== null ? ` (${decl.ownedByModuleGuess})` : "";
+  const sf = decl.node.getSourceFile();
+  let relatedMessage;
+  if (!sf.isDeclarationFile) {
+    const annotationType = type === "import" ? "@NgModule" : "Angular";
+    relatedMessage = `Is it missing an ${annotationType} annotation?`;
+  } else if (sf.fileName.indexOf("node_modules") !== -1) {
+    relatedMessage = `This likely means that the library${library} which declares ${decl.debugName} has not been processed correctly by ngcc, or is not compatible with Angular Ivy. Check if a newer version of the library is available, and update if so. Also consider checking with the library's authors to see if the library is expected to be compatible with Ivy.`;
+  } else {
+    relatedMessage = `This likely means that the dependency${library} which declares ${decl.debugName} has not been processed correctly by ngcc.`;
   }
-  const commentText = text.substring(comment.pos, comment.end);
-  if (commentText.indexOf("@license") !== -1) {
-    return null;
+  return makeDiagnostic(code, getDiagnosticNode(decl, rawExpr), message, [makeRelatedInformation(decl.node.name, relatedMessage)]);
+}
+function invalidTransitiveNgModuleRef(decl, rawExpr, type) {
+  const code = type === "import" ? ErrorCode.NGMODULE_INVALID_IMPORT : ErrorCode.NGMODULE_INVALID_EXPORT;
+  return makeDiagnostic(code, getDiagnosticNode(decl, rawExpr), `This ${type} contains errors, which may affect components that depend on this NgModule.`);
+}
+function invalidReexport(decl, rawExpr, isStandalone) {
+  let message = `Can't be exported from this NgModule, as `;
+  if (isStandalone) {
+    message += "it must be imported first";
+  } else if (decl.node.getSourceFile().isDeclarationFile) {
+    message += "it must be imported via its NgModule first";
+  } else {
+    message += "it must be either declared by this NgModule, or imported here via its NgModule first";
   }
-  return commentText;
+  return makeDiagnostic(ErrorCode.NGMODULE_INVALID_REEXPORT, getDiagnosticNode(decl, rawExpr), message);
 }
-function wrapInNoSideEffects(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 reexportCollision(module, refA, refB) {
+  const childMessageText = `This directive/pipe is part of the exports of '${module.name.text}' and shares the same name as another exported directive/pipe.`;
+  return makeDiagnostic(ErrorCode.NGMODULE_REEXPORT_NAME_COLLISION, module.name, `
+    There was a name collision between two classes named '${refA.node.name.text}', which are both part of the exports of '${module.name.text}'.
+
+    Angular generates re-exports of an NgModule's exported directives/pipes from the module's source file in certain cases, using the declared name of the class. If two classes of the same name are exported, this automatic naming does not work.
+
+    To fix this problem please re-export one or both classes directly from this file.
+  `.trim(), [
+    makeRelatedInformation(refA.node.name, childMessageText),
+    makeRelatedInformation(refB.node.name, childMessageText)
   ]);
 }
-function updateInitializers(stmt, update) {
-  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
-var ShimReferenceTagger = class {
-  constructor(shimExtensions) {
-    this.tagged = /* @__PURE__ */ new Set();
-    this.enabled = true;
-    this.suffixes = shimExtensions.map((extension) => `.${extension}.ts`);
-  }
-  tag(sf) {
-    if (!this.enabled || sf.isDeclarationFile || isShim(sf) || this.tagged.has(sf) || !isNonDeclarationTsPath(sf.fileName)) {
-      return;
-    }
-    const ext = sfExtensionData(sf);
-    if (ext.originalReferencedFiles === null) {
-      ext.originalReferencedFiles = sf.referencedFiles;
-    }
-    const referencedFiles = [...ext.originalReferencedFiles];
-    const sfPath = absoluteFromSourceFile(sf);
-    for (const suffix of this.suffixes) {
-      referencedFiles.push({
-        fileName: makeShimFileName(sfPath, suffix),
-        pos: 0,
-        end: 0
-      });
-    }
-    ext.taggedReferenceFiles = referencedFiles;
-    sf.referencedFiles = referencedFiles;
-    this.tagged.add(sf);
-  }
-  finalize() {
-    this.enabled = false;
-    this.tagged.clear();
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/scope/src/typecheck.mjs
+import { CssSelector, SelectorMatcher } from "@angular/compiler";
+import ts13 from "typescript";
+var TypeCheckScopeRegistry = class {
+  constructor(scopeReader, metaReader) {
+    this.scopeReader = scopeReader;
+    this.metaReader = metaReader;
+    this.flattenedDirectiveMetaCache = /* @__PURE__ */ new Map();
+    this.scopeCache = /* @__PURE__ */ new Map();
   }
-};
-
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/summary_generator.mjs
-import ts15 from "typescript";
-var SummaryGenerator = class {
-  constructor() {
-    this.shouldEmit = true;
-    this.extensionPrefix = "ngsummary";
-  }
-  generateShimForFile(sf, genFilePath) {
-    const symbolNames = [];
-    for (const stmt of sf.statements) {
-      if (ts15.isClassDeclaration(stmt)) {
-        if (!isExported2(stmt) || stmt.decorators === void 0 || stmt.name === void 0) {
-          continue;
-        }
-        symbolNames.push(stmt.name.text);
-      } 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) {
-          symbolNames.push(specifier.name.text);
+  getTypeCheckScope(node) {
+    const matcher = new SelectorMatcher();
+    const directives = [];
+    const pipes = /* @__PURE__ */ new Map();
+    const scope = this.scopeReader.getScopeForComponent(node);
+    if (scope === null) {
+      return {
+        matcher,
+        directives,
+        pipes,
+        schemas: [],
+        isPoisoned: false
+      };
+    }
+    const cacheKey = scope.kind === ComponentScopeKind.NgModule ? scope.ngModule : scope.component;
+    const dependencies = scope.kind === ComponentScopeKind.NgModule ? scope.compilation.dependencies : scope.dependencies;
+    if (this.scopeCache.has(cacheKey)) {
+      return this.scopeCache.get(cacheKey);
+    }
+    for (const meta of dependencies) {
+      if (meta.kind === MetaKind.Directive && meta.selector !== null) {
+        const extMeta = this.getTypeCheckDirectiveMetadata(meta.ref);
+        matcher.addSelectables(CssSelector.parse(meta.selector), extMeta);
+        directives.push(extMeta);
+      } else if (meta.kind === MetaKind.Pipe) {
+        if (!ts13.isClassDeclaration(meta.ref.node)) {
+          throw new Error(`Unexpected non-class declaration ${ts13.SyntaxKind[meta.ref.node.kind]} for pipe ${meta.ref.debugName}`);
         }
+        pipes.set(meta.name, meta.ref);
       }
     }
-    const varLines = symbolNames.map((name) => `export const ${name}NgSummary: any = null;`);
-    if (varLines.length === 0) {
-      varLines.push(`export const \u0275empty = null;`);
-    }
-    const sourceText = varLines.join("\n");
-    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");
+    const typeCheckScope = {
+      matcher,
+      directives,
+      pipes,
+      schemas: scope.schemas,
+      isPoisoned: scope.kind === ComponentScopeKind.NgModule ? scope.compilation.isPoisoned || scope.exported.isPoisoned : scope.isPoisoned
+    };
+    this.scopeCache.set(cacheKey, typeCheckScope);
+    return typeCheckScope;
+  }
+  getTypeCheckDirectiveMetadata(ref) {
+    const clazz = ref.node;
+    if (this.flattenedDirectiveMetaCache.has(clazz)) {
+      return this.flattenedDirectiveMetaCache.get(clazz);
     }
-    return genFile;
+    const meta = flattenInheritedDirectiveMetadata(this.metaReader, ref);
+    this.flattenedDirectiveMetaCache.set(clazz, meta);
+    return meta;
   }
 };
-function isExported2(decl) {
-  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/api.mjs
+var CompilationMode;
+(function(CompilationMode2) {
+  CompilationMode2[CompilationMode2["FULL"] = 0] = "FULL";
+  CompilationMode2[CompilationMode2["PARTIAL"] = 1] = "PARTIAL";
+})(CompilationMode || (CompilationMode = {}));
+var HandlerPrecedence;
+(function(HandlerPrecedence2) {
+  HandlerPrecedence2[HandlerPrecedence2["PRIMARY"] = 0] = "PRIMARY";
+  HandlerPrecedence2[HandlerPrecedence2["SHARED"] = 1] = "SHARED";
+  HandlerPrecedence2[HandlerPrecedence2["WEAK"] = 2] = "WEAK";
+})(HandlerPrecedence || (HandlerPrecedence = {}));
+var HandlerFlags;
+(function(HandlerFlags2) {
+  HandlerFlags2[HandlerFlags2["NONE"] = 0] = "NONE";
+  HandlerFlags2[HandlerFlags2["FULL_INHERITANCE"] = 1] = "FULL_INHERITANCE";
+})(HandlerFlags || (HandlerFlags = {}));
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/alias.mjs
+import ts14 from "typescript";
+function aliasTransformFactory(exportStatements) {
+  return (context) => {
+    return (file) => {
+      if (ts14.isBundle(file) || !exportStatements.has(file.fileName)) {
+        return file;
+      }
+      const statements = [...file.statements];
+      exportStatements.get(file.fileName).forEach(([moduleName, symbolName], aliasName) => {
+        const stmt = ts14.factory.createExportDeclaration(void 0, void 0, false, ts14.createNamedExports([ts14.factory.createExportSpecifier(false, symbolName, aliasName)]), ts14.factory.createStringLiteral(moduleName));
+        statements.push(stmt);
+      });
+      return ts14.factory.updateSourceFile(file, statements);
+    };
+  };
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
+import ts15 from "typescript";
+
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/trait.mjs
 var TraitState;
 (function(TraitState2) {
@@ -2927,7 +3135,7 @@ var TraitImpl = class {
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/compilation.mjs
 var TraitCompiler = class {
-  constructor(handlers, reflector, perf, incrementalBuild, compileNonExportedClasses, compilationMode, dtsTransforms, semanticDepGraphUpdater) {
+  constructor(handlers, reflector, perf, incrementalBuild, compileNonExportedClasses, compilationMode, dtsTransforms, semanticDepGraphUpdater, sourceFileTypeIdentifier) {
     this.handlers = handlers;
     this.reflector = reflector;
     this.perf = perf;
@@ -2936,6 +3144,7 @@ var TraitCompiler = class {
     this.compilationMode = compilationMode;
     this.dtsTransforms = dtsTransforms;
     this.semanticDepGraphUpdater = semanticDepGraphUpdater;
+    this.sourceFileTypeIdentifier = sourceFileTypeIdentifier;
     this.classes = /* @__PURE__ */ new Map();
     this.fileToClasses = /* @__PURE__ */ new Map();
     this.filesWithoutTraits = /* @__PURE__ */ new Set();
@@ -2952,7 +3161,7 @@ var TraitCompiler = class {
     return this.analyze(sf, true);
   }
   analyze(sf, preanalyze) {
-    if (sf.isDeclarationFile || isShim(sf)) {
+    if (sf.isDeclarationFile || this.sourceFileTypeIdentifier.isShim(sf) || this.sourceFileTypeIdentifier.isResource(sf)) {
       return void 0;
     }
     const promises = [];
@@ -2973,7 +3182,7 @@ var TraitCompiler = class {
       if (this.reflector.isClass(node)) {
         this.analyzeClass(node, preanalyze ? promises : null);
       }
-      ts16.forEachChild(node, visit2);
+      ts15.forEachChild(node, visit2);
     };
     visit2(sf);
     if (!this.fileToClasses.has(sf)) {
@@ -3087,7 +3296,7 @@ var TraitCompiler = class {
         }
         if (isPrimaryHandler && record.hasPrimaryHandler) {
           record.metaDiagnostics = [{
-            category: ts16.DiagnosticCategory.Error,
+            category: ts15.DiagnosticCategory.Error,
             code: Number("-99" + ErrorCode.DECORATOR_COLLISION),
             file: getSourceFile(clazz),
             start: clazz.getStart(void 0, false),
@@ -3295,7 +3504,7 @@ var TraitCompiler = class {
     }
   }
   compile(clazz, constantPool) {
-    const original = ts16.getOriginalNode(clazz);
+    const original = ts15.getOriginalNode(clazz);
     if (!this.reflector.isClass(clazz) || !this.reflector.isClass(original) || !this.classes.has(original)) {
       return null;
     }
@@ -3326,7 +3535,7 @@ var TraitCompiler = class {
     return res.length > 0 ? res : null;
   }
   decoratorsFor(node) {
-    const original = ts16.getOriginalNode(node);
+    const original = ts15.getOriginalNode(node);
     if (!this.reflector.isClass(original) || !this.classes.has(original)) {
       return [];
     }
@@ -3336,7 +3545,7 @@ var TraitCompiler = class {
       if (trait.state !== TraitState.Resolved) {
         continue;
       }
-      if (trait.detected.trigger !== null && ts16.isDecorator(trait.detected.trigger)) {
+      if (trait.detected.trigger !== null && ts15.isDecorator(trait.detected.trigger)) {
         decorators.push(trait.detected.trigger);
       }
     }
@@ -3365,27 +3574,27 @@ var TraitCompiler = class {
   }
 };
 function containsErrors(diagnostics) {
-  return diagnostics !== null && diagnostics.some((diag) => diag.category === ts16.DiagnosticCategory.Error);
+  return diagnostics !== null && diagnostics.some((diag) => diag.category === ts15.DiagnosticCategory.Error);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
-import ts18 from "typescript";
+import ts17 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/utils.mjs
-import ts17 from "typescript";
+import ts16 from "typescript";
 function addImports(importManager, sf, extraStatements = []) {
   const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
-    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);
+    const qualifier = ts16.factory.createIdentifier(i.qualifier.text);
+    const importClause = ts16.factory.createImportClause(false, void 0, ts16.factory.createNamespaceImport(qualifier));
+    const decl = ts16.factory.createImportDeclaration(void 0, void 0, importClause, ts16.factory.createStringLiteral(i.specifier));
+    ts16.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 = ts17.factory.createNotEmittedStatement(sf);
-    return ts17.factory.updateSourceFile(sf, ts17.factory.createNodeArray([
+    const fileoverviewAnchorStmt = ts16.factory.createNotEmittedStatement(sf);
+    return ts16.factory.updateSourceFile(sf, ts16.factory.createNodeArray([
       fileoverviewAnchorStmt,
       ...existingImports,
       ...addedImports,
@@ -3396,7 +3605,7 @@ function addImports(importManager, sf, extraStatements = []) {
   return sf;
 }
 function isImportStatement(stmt) {
-  return ts17.isImportDeclaration(stmt) || ts17.isImportEqualsDeclaration(stmt) || ts17.isNamespaceImport(stmt);
+  return ts16.isImportDeclaration(stmt) || ts16.isImportEqualsDeclaration(stmt) || ts16.isNamespaceImport(stmt);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
@@ -3414,7 +3623,7 @@ var DtsTransformRegistry = class {
     if (!sf.isDeclarationFile) {
       return null;
     }
-    const originalSf = ts18.getOriginalNode(sf);
+    const originalSf = ts17.getOriginalNode(sf);
     let transforms = null;
     if (this.ivyDeclarationTransforms.has(originalSf)) {
       transforms = [];
@@ -3427,7 +3636,7 @@ function declarationTransformFactory(transformRegistry, importRewriter, importPr
   return (context) => {
     const transformer = new DtsTransformer(context, importRewriter, importPrefix);
     return (fileOrBundle) => {
-      if (ts18.isBundle(fileOrBundle)) {
+      if (ts17.isBundle(fileOrBundle)) {
         return fileOrBundle;
       }
       const transforms = transformRegistry.getAllTransforms(fileOrBundle);
@@ -3447,15 +3656,15 @@ var DtsTransformer = class {
   transform(sf, transforms) {
     const imports = new ImportManager(this.importRewriter, this.importPrefix);
     const visitor = (node) => {
-      if (ts18.isClassDeclaration(node)) {
+      if (ts17.isClassDeclaration(node)) {
         return this.transformClassDeclaration(node, transforms, imports);
-      } else if (ts18.isFunctionDeclaration(node)) {
+      } else if (ts17.isFunctionDeclaration(node)) {
         return this.transformFunctionDeclaration(node, transforms, imports);
       } else {
-        return ts18.visitEachChild(node, visitor, this.ctx);
+        return ts17.visitEachChild(node, visitor, this.ctx);
       }
     };
-    sf = ts18.visitNode(sf, visitor);
+    sf = ts17.visitNode(sf, visitor);
     return addImports(imports, sf);
   }
   transformClassDeclaration(clazz, transforms, imports) {
@@ -3483,7 +3692,7 @@ var DtsTransformer = class {
       }
     }
     if (elementsChanged && clazz === newClazz) {
-      newClazz = ts18.factory.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, elements);
+      newClazz = ts17.factory.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, elements);
     }
     return newClazz;
   }
@@ -3505,31 +3714,31 @@ var IvyDeclarationDtsTransform = class {
     this.declarationFields.set(decl, fields);
   }
   transformClass(clazz, members, imports) {
-    const original = ts18.getOriginalNode(clazz);
+    const original = ts17.getOriginalNode(clazz);
     if (!this.declarationFields.has(original)) {
       return clazz;
     }
     const fields = this.declarationFields.get(original);
     const newMembers = fields.map((decl) => {
-      const modifiers = [ts18.factory.createModifier(ts18.SyntaxKind.StaticKeyword)];
+      const modifiers = [ts17.factory.createModifier(ts17.SyntaxKind.StaticKeyword)];
       const typeRef = translateType(decl.type, imports);
       markForEmitAsSingleLine(typeRef);
-      return ts18.factory.createPropertyDeclaration(void 0, modifiers, decl.name, void 0, typeRef, void 0);
+      return ts17.factory.createPropertyDeclaration(void 0, modifiers, decl.name, void 0, typeRef, void 0);
     });
-    return ts18.factory.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, [...members, ...newMembers]);
+    return ts17.factory.updateClassDeclaration(clazz, clazz.decorators, clazz.modifiers, clazz.name, clazz.typeParameters, clazz.heritageClauses, [...members, ...newMembers]);
   }
 };
 function markForEmitAsSingleLine(node) {
-  ts18.setEmitFlags(node, ts18.EmitFlags.SingleLine);
-  ts18.forEachChild(node, markForEmitAsSingleLine);
+  ts17.setEmitFlags(node, ts17.EmitFlags.SingleLine);
+  ts17.forEachChild(node, markForEmitAsSingleLine);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
 import { ConstantPool } from "@angular/compiler";
-import ts20 from "typescript";
+import ts19 from "typescript";
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/visitor.mjs
-import ts19 from "typescript";
+import ts18 from "typescript";
 function visit(node, visitor, context) {
   return visitor._visit(node, context);
 }
@@ -3553,8 +3762,8 @@ var Visitor = class {
   }
   _visit(node, context) {
     let visitedNode = null;
-    node = ts19.visitEachChild(node, (child) => this._visit(child, context), context);
-    if (ts19.isClassDeclaration(node)) {
+    node = ts18.visitEachChild(node, (child) => this._visit(child, context), context);
+    if (ts18.isClassDeclaration(node)) {
       visitedNode = this._visitListEntryNode(node, (node2) => this.visitClassDeclaration(node2));
     } else {
       visitedNode = this.visitOtherNode(node);
@@ -3568,7 +3777,7 @@ var Visitor = class {
     if (node.statements.every((stmt) => !this._before.has(stmt) && !this._after.has(stmt))) {
       return node;
     }
-    const clone = ts19.getMutableClone(node);
+    const clone = ts18.getMutableClone(node);
     const newStatements = [];
     clone.statements.forEach((stmt) => {
       if (this._before.has(stmt)) {
@@ -3581,7 +3790,7 @@ var Visitor = class {
         this._after.delete(stmt);
       }
     });
-    clone.statements = ts19.factory.createNodeArray(newStatements, node.statements.hasTrailingComma);
+    clone.statements = ts18.factory.createNodeArray(newStatements, node.statements.hasTrailingComma);
     return clone;
   }
 };
@@ -3639,14 +3848,14 @@ var IvyTransformationVisitor = class extends Visitor {
     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);
+      const property = ts19.factory.createPropertyDeclaration(void 0, [ts19.factory.createToken(ts19.SyntaxKind.StaticKeyword)], field.name, void 0, void 0, exprNode);
       if (this.isClosureCompilerEnabled) {
-        ts20.addSyntheticLeadingComment(property, ts20.SyntaxKind.MultiLineCommentTrivia, "* @nocollapse ", false);
+        ts19.addSyntheticLeadingComment(property, ts19.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)));
+    node = ts19.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) {
@@ -3675,25 +3884,25 @@ var IvyTransformationVisitor = class extends Visitor {
     if (filtered.length === 0) {
       return void 0;
     }
-    const array = ts20.factory.createNodeArray(filtered);
+    const array = ts19.factory.createNodeArray(filtered);
     array.pos = node.decorators.pos;
     array.end = node.decorators.end;
     return array;
   }
   _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)) {
+    if (ts19.isParameter(node)) {
+      node = ts19.factory.updateParameterDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+    } else if (ts19.isMethodDeclaration(node) && node.decorators !== void 0) {
+      node = ts19.factory.updateMethodDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
+    } else if (ts19.isPropertyDeclaration(node) && node.decorators !== void 0) {
+      node = ts19.factory.updatePropertyDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.questionToken, node.type, node.initializer);
+    } else if (ts19.isGetAccessor(node)) {
+      node = ts19.factory.updateGetAccessorDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.parameters, node.type, node.body);
+    } else if (ts19.isSetAccessor(node)) {
+      node = ts19.factory.updateSetAccessorDeclaration(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.name, node.parameters, node.body);
+    } else if (ts19.isConstructorDeclaration(node)) {
       const parameters = node.parameters.map((param) => this._stripAngularDecorators(param));
-      node = ts20.factory.updateConstructorDeclaration(node, node.decorators, node.modifiers, parameters, node.body);
+      node = ts19.factory.updateConstructorDeclaration(node, node.decorators, node.modifiers, parameters, node.body);
     }
     return node;
   }
@@ -3705,7 +3914,7 @@ function transformIvySourceFile(compilation, context, reflector, importRewriter,
   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 downlevelTranslatedCode = getLocalizeCompileTarget(context) < ts19.ScriptTarget.ES2015;
   const constants = constantPool.statements.map((stmt) => translateStatement(stmt, importManager, {
     recordWrappedNode,
     downlevelTaggedTemplates: downlevelTranslatedCode,
@@ -3720,17 +3929,17 @@ function transformIvySourceFile(compilation, context, reflector, importRewriter,
   return sf;
 }
 function getLocalizeCompileTarget(context) {
-  const target = context.getCompilerOptions().target || ts20.ScriptTarget.ES2015;
-  return target !== ts20.ScriptTarget.JSON ? target : ts20.ScriptTarget.ES2015;
+  const target = context.getCompilerOptions().target || ts19.ScriptTarget.ES2015;
+  return target !== ts19.ScriptTarget.JSON ? target : ts19.ScriptTarget.ES2015;
 }
 function getFileOverviewComment(statements) {
   if (statements.length > 0) {
     const host = statements[0];
     let trailing = false;
-    let comments = ts20.getSyntheticLeadingComments(host);
+    let comments = ts19.getSyntheticLeadingComments(host);
     if (!comments || comments.length === 0) {
       trailing = true;
-      comments = ts20.getSyntheticTrailingComments(host);
+      comments = ts19.getSyntheticTrailingComments(host);
     }
     if (comments && comments.length > 0 && CLOSURE_FILE_OVERVIEW_REGEXP.test(comments[0].text)) {
       return { comments, host, trailing };
@@ -3742,22 +3951,22 @@ 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);
+      ts19.setSyntheticTrailingComments(host, void 0);
     } else {
-      ts20.setSyntheticLeadingComments(host, void 0);
+      ts19.setSyntheticLeadingComments(host, void 0);
     }
-    ts20.setSyntheticLeadingComments(sf.statements[0], comments);
+    ts19.setSyntheticLeadingComments(sf.statements[0], comments);
   }
 }
 function maybeFilterDecorator(decorators, toRemove) {
   if (decorators === void 0) {
     return void 0;
   }
-  const filtered = decorators.filter((dec) => toRemove.find((decToRemove) => ts20.getOriginalNode(dec) === decToRemove) === void 0);
+  const filtered = decorators.filter((dec) => toRemove.find((decToRemove) => ts19.getOriginalNode(dec) === decToRemove) === void 0);
   if (filtered.length === 0) {
     return void 0;
   }
-  return ts20.factory.createNodeArray(filtered);
+  return ts19.factory.createNodeArray(filtered);
 }
 function isFromAngularCore(decorator) {
   return decorator.import !== null && decorator.import.from === "@angular/core";
@@ -3775,8 +3984,8 @@ function createRecorderFn(defaultImportTracker) {
 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";
+import { createMayBeForwardRefExpression, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr4, getSafePropertyAccessString, parseHostBindings, verifyHostBindings, WrappedNodeExpr as WrappedNodeExpr4 } from "@angular/compiler";
+import ts20 from "typescript";
 var EMPTY_OBJECT = {};
 var QUERY_TYPES = /* @__PURE__ */ new Set([
   "ContentChild",
@@ -3792,7 +4001,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 (!ts21.isObjectLiteralExpression(meta)) {
+    if (!ts20.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `@${decorator.name} argument must be an object literal`);
     }
     directive = reflectObjectLiteral(meta);
@@ -3844,7 +4053,7 @@ 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");
+  const isStructural = ctorDeps !== null && ctorDeps !== "invalid" && ctorDeps.some((dep) => dep.token instanceof ExternalExpr4 && dep.token.value.moduleName === "@angular/core" && dep.token.value.name === "TemplateRef");
   let isStandalone = false;
   if (directive.has("standalone")) {
     const expr = directive.get("standalone");
@@ -3913,7 +4122,7 @@ function extractQueryMetadata(exprNode, name, args, propertyName, reflector, eva
   let emitDistinctChangesOnly = emitDistinctChangesOnlyDefaultValue;
   if (args.length === 2) {
     const optionsExpr = unwrapExpression(args[1]);
-    if (!ts21.isObjectLiteralExpression(optionsExpr)) {
+    if (!ts20.isObjectLiteralExpression(optionsExpr)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, optionsExpr, `@${name} options must be an object literal`);
     }
     const options = reflectObjectLiteral(optionsExpr);
@@ -4008,16 +4217,16 @@ function extractHostBindings(members, evaluator, coreModule, metadata) {
 }
 function extractQueriesFromDecorator(queryData, reflector, evaluator, isCore) {
   const content = [], view = [];
-  if (!ts21.isObjectLiteralExpression(queryData)) {
+  if (!ts20.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 (!ts21.isNewExpression(queryExpr)) {
+    if (!ts20.isNewExpression(queryExpr)) {
       throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, "Decorator query metadata must be an instance of a query type");
     }
-    const queryType = ts21.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
-    if (!ts21.isIdentifier(queryType)) {
+    const queryType = ts20.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
+    if (!ts20.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);
@@ -4263,6 +4472,9 @@ var DirectiveDecoratorHandler = class {
   }
   analyze(node, decorator, flags = HandlerFlags.NONE) {
     if (this.compileUndecoratedClassesWithAngularFeatures === false && decorator === null) {
+      if (this.isCore) {
+        return {};
+      }
       return { diagnostics: [getUndecoratedClassWithAngularFeaturesDiagnostic(node)] };
     }
     this.perf.eventCount(PerfEvent.AnalyzeDirective);
@@ -4296,7 +4508,7 @@ var DirectiveDecoratorHandler = class {
   register(node, analysis) {
     const ref = new Reference(node);
     this.metaRegistry.registerDirectiveMetadata(__spreadProps(__spreadValues({
-      type: MetaType.Directive,
+      kind: MetaKind.Directive,
       ref,
       name: node.name.text,
       selector: analysis.meta.selector,
@@ -4310,7 +4522,9 @@ var DirectiveDecoratorHandler = class {
       isPoisoned: analysis.isPoisoned,
       isStructural: analysis.isStructural,
       animationTriggerNames: null,
-      isStandalone: analysis.meta.isStandalone
+      isStandalone: analysis.meta.isStandalone,
+      imports: null,
+      schemas: null
     }));
     this.injectableRegistry.registerInjectable(node);
   }
@@ -4355,8 +4569,8 @@ var DirectiveDecoratorHandler = class {
 };
 
 // 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, R3SelectorScopeMode, WrappedNodeExpr as WrappedNodeExpr6 } from "@angular/compiler";
-import ts22 from "typescript";
+import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, ExternalExpr as ExternalExpr5, FactoryTarget as FactoryTarget2, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr2, R3Identifiers, R3SelectorScopeMode, WrappedNodeExpr as WrappedNodeExpr6 } from "@angular/compiler";
+import ts21 from "typescript";
 var NgModuleSymbol = class extends SemanticSymbol {
   constructor() {
     super(...arguments);
@@ -4439,8 +4653,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]) : ts22.factory.createObjectLiteralExpression([]);
-    if (!ts22.isObjectLiteralExpression(meta)) {
+    const meta = decorator.args.length === 1 ? unwrapExpression(decorator.args[0]) : ts21.factory.createObjectLiteralExpression([]);
+    if (!ts21.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@NgModule argument must be an object literal");
     }
     const ngModule = reflectObjectLiteral(meta);
@@ -4448,7 +4662,7 @@ var NgModuleDecoratorHandler = class {
       return {};
     }
     const moduleResolvers = combineResolvers([
-      (ref) => this._extractModuleFromModuleWithProvidersFn(ref.node),
+      (fn, call, resolve, unresolvable) => this._extractModuleFromModuleWithProvidersFn(fn, call, resolve, unresolvable),
       forwardRefResolver
     ]);
     const diagnostics = [];
@@ -4457,7 +4671,7 @@ var NgModuleDecoratorHandler = class {
     if (ngModule.has("declarations")) {
       rawDeclarations = ngModule.get("declarations");
       const declarationMeta = this.evaluator.evaluate(rawDeclarations, forwardRefResolver);
-      declarationRefs = this.resolveTypeList(rawDeclarations, declarationMeta, name, "declarations");
+      declarationRefs = this.resolveTypeList(rawDeclarations, declarationMeta, name, "declarations", 0).references;
       for (const ref of declarationRefs) {
         if (ref.node.getSourceFile().isDeclarationFile) {
           const errorNode = ref.getOriginForDiagnostics(rawDeclarations);
@@ -4469,51 +4683,33 @@ var NgModuleDecoratorHandler = class {
       return { diagnostics };
     }
     let importRefs = [];
+    let rawImports = null;
     if (ngModule.has("imports")) {
-      const rawImports = ngModule.get("imports");
+      rawImports = ngModule.get("imports");
       const importsMeta = this.evaluator.evaluate(rawImports, moduleResolvers);
-      importRefs = this.resolveTypeList(rawImports, importsMeta, name, "imports");
+      importRefs = this.resolveTypeList(rawImports, importsMeta, name, "imports", 0).references;
     }
     let exportRefs = [];
+    let rawExports = null;
     if (ngModule.has("exports")) {
-      const rawExports = ngModule.get("exports");
+      rawExports = ngModule.get("exports");
       const exportsMeta = this.evaluator.evaluate(rawExports, moduleResolvers);
-      exportRefs = this.resolveTypeList(rawExports, exportsMeta, name, "exports");
+      exportRefs = this.resolveTypeList(rawExports, exportsMeta, name, "exports", 0).references;
       this.referencesRegistry.add(node, ...exportRefs);
     }
     let bootstrapRefs = [];
     if (ngModule.has("bootstrap")) {
       const expr = ngModule.get("bootstrap");
       const bootstrapMeta = this.evaluator.evaluate(expr, forwardRefResolver);
-      bootstrapRefs = this.resolveTypeList(expr, bootstrapMeta, name, "bootstrap");
-    }
-    const schemas = [];
-    if (ngModule.has("schemas")) {
-      const rawExpr = ngModule.get("schemas");
-      const result = this.evaluator.evaluate(rawExpr);
-      if (!Array.isArray(result)) {
-        throw createValueHasWrongTypeError(rawExpr, result, `NgModule.schemas must be an array`);
-      }
-      for (const schemaRef of result) {
-        if (!(schemaRef instanceof Reference)) {
-          throw createValueHasWrongTypeError(rawExpr, result, "NgModule.schemas must be an array of schemas");
-        }
-        const id2 = schemaRef.getIdentityIn(schemaRef.node.getSourceFile());
-        if (id2 === null || schemaRef.ownedByModuleGuess !== "@angular/core") {
-          throw createValueHasWrongTypeError(rawExpr, result, "NgModule.schemas must be an array of schemas");
-        }
-        switch (id2.text) {
-          case "CUSTOM_ELEMENTS_SCHEMA":
-            schemas.push(CUSTOM_ELEMENTS_SCHEMA);
-            break;
-          case "NO_ERRORS_SCHEMA":
-            schemas.push(NO_ERRORS_SCHEMA);
-            break;
-          default:
-            throw createValueHasWrongTypeError(rawExpr, schemaRef, `'${schemaRef.debugName}' is not a valid NgModule schema`);
+      bootstrapRefs = this.resolveTypeList(expr, bootstrapMeta, name, "bootstrap", 0).references;
+      for (const ref of bootstrapRefs) {
+        const dirMeta = this.metaReader.getDirectiveMetadata(ref);
+        if (dirMeta == null ? void 0 : dirMeta.isStandalone) {
+          diagnostics.push(makeStandaloneBootstrapDiagnostic(node, ref, expr));
         }
       }
     }
+    const schemas = ngModule.has("schemas") ? extractSchemas(ngModule.get("schemas"), this.evaluator, "NgModule") : [];
     let id = null;
     if (ngModule.has("id")) {
       const idExpr = ngModule.get("id");
@@ -4521,7 +4717,7 @@ var NgModuleDecoratorHandler = class {
         id = new WrappedNodeExpr6(idExpr);
       } else {
         const diag = makeDiagnostic(ErrorCode.WARN_NGMODULE_ID_UNNECESSARY, idExpr, `Using 'module.id' for NgModule.id is a common anti-pattern that is ignored by the Angular compiler.`);
-        diag.category = ts22.DiagnosticCategory.Warning;
+        diag.category = ts21.DiagnosticCategory.Warning;
         diagnostics.push(diag);
       }
     }
@@ -4555,16 +4751,38 @@ var NgModuleDecoratorHandler = class {
     };
     const rawProviders = ngModule.has("providers") ? ngModule.get("providers") : null;
     const wrapperProviders = rawProviders !== null ? new WrappedNodeExpr6(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(rawProviders) : rawProviders) : null;
-    const injectorImports = [];
+    const topLevelImports = [];
     if (ngModule.has("imports")) {
-      injectorImports.push(new WrappedNodeExpr6(ngModule.get("imports")));
+      const rawImports2 = unwrapExpression(ngModule.get("imports"));
+      let topLevelExpressions = [];
+      if (ts21.isArrayLiteralExpression(rawImports2)) {
+        for (const element of rawImports2.elements) {
+          if (ts21.isSpreadElement(element)) {
+            topLevelExpressions.push(element.expression);
+            continue;
+          }
+          topLevelExpressions.push(element);
+        }
+      } else {
+        topLevelExpressions.push(rawImports2);
+      }
+      let absoluteIndex = 0;
+      for (const importExpr of topLevelExpressions) {
+        const resolved = this.evaluator.evaluate(importExpr, moduleResolvers);
+        const { references, hasModuleWithProviders } = this.resolveTypeList(importExpr, [resolved], node.name.text, "imports", absoluteIndex);
+        absoluteIndex += references.length;
+        topLevelImports.push({
+          expression: importExpr,
+          resolvedReferences: references,
+          hasModuleWithProviders
+        });
+      }
     }
     const injectorMetadata = {
       name,
       type,
       internalType,
-      providers: wrapperProviders,
-      imports: injectorImports
+      providers: wrapperProviders
     };
     const factoryMetadata = {
       name,
@@ -4584,8 +4802,11 @@ var NgModuleDecoratorHandler = class {
         fac: factoryMetadata,
         declarations: declarationRefs,
         rawDeclarations,
-        imports: importRefs,
+        imports: topLevelImports,
+        rawImports,
+        importRefs,
         exports: exportRefs,
+        rawExports,
         providers: rawProviders,
         providersRequiringFactory: rawProviders ? resolveProvidersRequiringFactory(rawProviders, this.reflector, this.evaluator) : null,
         classMetadata: extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
@@ -4598,12 +4819,15 @@ var NgModuleDecoratorHandler = class {
   }
   register(node, analysis) {
     this.metaRegistry.registerNgModuleMetadata({
+      kind: MetaKind.NgModule,
       ref: new Reference(node),
       schemas: analysis.schemas,
       declarations: analysis.declarations,
-      imports: analysis.imports,
+      imports: analysis.importRefs,
       exports: analysis.exports,
-      rawDeclarations: analysis.rawDeclarations
+      rawDeclarations: analysis.rawDeclarations,
+      rawImports: analysis.rawImports,
+      rawExports: analysis.rawExports
     });
     if (this.factoryTracker !== null) {
       this.factoryTracker.track(node.getSourceFile(), {
@@ -4626,6 +4850,34 @@ var NgModuleDecoratorHandler = class {
     const data = {
       injectorImports: []
     };
+    for (const topLevelImport of analysis.imports) {
+      if (topLevelImport.hasModuleWithProviders) {
+        data.injectorImports.push(new WrappedNodeExpr6(topLevelImport.expression));
+        continue;
+      }
+      const refsToEmit = [];
+      for (const ref of topLevelImport.resolvedReferences) {
+        const dirMeta = this.metaReader.getDirectiveMetadata(ref);
+        if (dirMeta !== null && !dirMeta.isComponent) {
+          continue;
+        }
+        const pipeMeta = dirMeta === null ? this.metaReader.getPipeMetadata(ref) : null;
+        if (pipeMeta !== null) {
+          continue;
+        }
+        refsToEmit.push(ref);
+      }
+      if (refsToEmit.length === topLevelImport.resolvedReferences.length) {
+        data.injectorImports.push(new WrappedNodeExpr6(topLevelImport.expression));
+      } else {
+        const context = node.getSourceFile();
+        for (const ref of refsToEmit) {
+          const emittedRef = this.refEmitter.emit(ref, context);
+          assertSuccessfulReferenceEmit(emittedRef, topLevelImport.expression, "class");
+          data.injectorImports.push(emittedRef.expression);
+        }
+      }
+    }
     if (scope !== null && !scope.compilation.isPoisoned) {
       const context = getSourceFile(node);
       for (const exportRef of analysis.exports) {
@@ -4642,15 +4894,8 @@ var NgModuleDecoratorHandler = class {
           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?`));
-        }
       }
     }
     if (diagnostics.length > 0) {
@@ -4667,7 +4912,9 @@ var NgModuleDecoratorHandler = class {
   }
   compileFull(node, { inj, mod, fac, classMetadata, declarations }, { injectorImports }) {
     const factoryFn = compileNgFactoryDefField(fac);
-    const ngInjectorDef = compileInjector(this.mergeInjectorImports(inj, injectorImports));
+    const ngInjectorDef = compileInjector(__spreadProps(__spreadValues({}, inj), {
+      imports: injectorImports
+    }));
     const ngModuleDef = compileNgModule(mod);
     const statements = ngModuleDef.statements;
     const metadata = classMetadata !== null ? compileClassMetadata2(classMetadata) : null;
@@ -4677,15 +4924,14 @@ var NgModuleDecoratorHandler = class {
   }
   compilePartial(node, { inj, fac, mod, classMetadata }, { injectorImports }) {
     const factoryFn = compileDeclareFactory(fac);
-    const injectorDef = compileDeclareInjectorFromMetadata(this.mergeInjectorImports(inj, injectorImports));
+    const injectorDef = compileDeclareInjectorFromMetadata(__spreadProps(__spreadValues({}, inj), {
+      imports: injectorImports
+    }));
     const ngModuleDef = compileDeclareNgModuleFromMetadata(mod);
     const metadata = classMetadata !== null ? compileDeclareClassMetadata2(classMetadata) : null;
     this.insertMetadataStatement(ngModuleDef.statements, metadata);
     return this.compileNgModule(factoryFn, injectorDef, ngModuleDef);
   }
-  mergeInjectorImports(inj, injectorImports) {
-    return __spreadProps(__spreadValues({}, inj), { imports: [...inj.imports, ...injectorImports] });
-  }
   insertMetadataStatement(ngModuleStatements, metadata) {
     if (metadata !== null) {
       ngModuleStatements.unshift(metadata.toStmt());
@@ -4711,7 +4957,7 @@ var NgModuleDecoratorHandler = class {
         const componentType = this.refEmitter.emit(decl, context);
         assertSuccessfulReferenceEmit(componentType, node, "component");
         const declExpr = componentType.expression;
-        const setComponentScope = new ExternalExpr4(R3Identifiers.setComponentScope);
+        const setComponentScope = new ExternalExpr5(R3Identifiers.setComponentScope);
         const callExpr = new InvokeFunctionExpr(setComponentScope, [declExpr, directiveArray, pipesArray]);
         ngModuleStatements.push(callExpr.toStmt());
       }
@@ -4747,15 +4993,26 @@ var NgModuleDecoratorHandler = class {
       return toR3Reference(origin, valueRef, typeRef, valueContext, typeContext, this.refEmitter);
     }
   }
-  _extractModuleFromModuleWithProvidersFn(node) {
-    const type = node.type || null;
-    return type && (this._reflectModuleFromTypeParam(type, node) || this._reflectModuleFromLiteralType(type));
+  _extractModuleFromModuleWithProvidersFn(fn, node, resolve, unresolvable) {
+    const rawType = fn.node.type || null;
+    const type = rawType && (this._reflectModuleFromTypeParam(rawType, fn.node) || this._reflectModuleFromLiteralType(rawType));
+    if (type === null) {
+      return unresolvable;
+    }
+    const ngModule = resolve(type);
+    if (!(ngModule instanceof Reference) || !isNamedClassDeclaration(ngModule.node)) {
+      return unresolvable;
+    }
+    return new SyntheticValue({
+      ngModule,
+      mwpCall: node
+    });
   }
   _reflectModuleFromTypeParam(type, node) {
-    if (!ts22.isTypeReferenceNode(type)) {
+    if (!ts21.isTypeReferenceNode(type)) {
       return null;
     }
-    const typeName = type && (ts22.isIdentifier(type.typeName) && type.typeName || ts22.isQualifiedName(type.typeName) && type.typeName.right) || null;
+    const typeName = type && (ts21.isIdentifier(type.typeName) && type.typeName || ts21.isQualifiedName(type.typeName) && type.typeName.right) || null;
     if (typeName === null) {
       return null;
     }
@@ -4767,7 +5024,7 @@ var NgModuleDecoratorHandler = class {
       return null;
     }
     if (type.typeArguments === void 0 || type.typeArguments.length !== 1) {
-      const parent = ts22.isMethodDeclaration(node) && ts22.isClassDeclaration(node.parent) ? node.parent : null;
+      const parent = ts21.isMethodDeclaration(node) && ts21.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.`);
     }
@@ -4775,13 +5032,13 @@ var NgModuleDecoratorHandler = class {
     return typeNodeToValueExpr(arg);
   }
   _reflectModuleFromLiteralType(type) {
-    if (!ts22.isIntersectionTypeNode(type)) {
+    if (!ts21.isIntersectionTypeNode(type)) {
       return null;
     }
     for (const t of type.types) {
-      if (ts22.isTypeLiteralNode(t)) {
+      if (ts21.isTypeLiteralNode(t)) {
         for (const m of t.members) {
-          const ngModuleType = ts22.isPropertySignature(m) && ts22.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
+          const ngModuleType = ts21.isPropertySignature(m) && ts21.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
           const ngModuleExpression = ngModuleType && typeNodeToValueExpr(ngModuleType);
           if (ngModuleExpression) {
             return ngModuleExpression;
@@ -4794,34 +5051,56 @@ var NgModuleDecoratorHandler = class {
   isClassDeclarationReference(ref) {
     return this.reflector.isClass(ref.node);
   }
-  resolveTypeList(expr, resolvedList, className, arrayName) {
+  resolveTypeList(expr, resolvedList, className, arrayName, absoluteIndex) {
+    let hasModuleWithProviders = false;
     const refList = [];
     if (!Array.isArray(resolvedList)) {
       throw createValueHasWrongTypeError(expr, resolvedList, `Expected array when reading the NgModule.${arrayName} of ${className}`);
     }
-    resolvedList.forEach((entry, idx) => {
-      if (entry instanceof Map && entry.has("ngModule")) {
+    for (let idx = 0; idx < resolvedList.length; idx++) {
+      let entry = resolvedList[idx];
+      if (entry instanceof SyntheticValue && isResolvedModuleWithProviders(entry)) {
+        entry = entry.value.ngModule;
+        hasModuleWithProviders = true;
+      } else if (entry instanceof Map && entry.has("ngModule")) {
         entry = entry.get("ngModule");
+        hasModuleWithProviders = true;
       }
       if (Array.isArray(entry)) {
-        refList.push(...this.resolveTypeList(expr, entry, className, arrayName));
+        const recursiveResult = this.resolveTypeList(expr, entry, className, arrayName, absoluteIndex);
+        refList.push(...recursiveResult.references);
+        absoluteIndex += recursiveResult.references.length;
+        hasModuleWithProviders = hasModuleWithProviders || recursiveResult.hasModuleWithProviders;
       } else if (entry instanceof Reference) {
         if (!this.isClassDeclarationReference(entry)) {
-          throw createValueHasWrongTypeError(entry.node, entry, `Value at position ${idx} in the NgModule.${arrayName} of ${className} is not a class`);
+          throw createValueHasWrongTypeError(entry.node, entry, `Value at position ${absoluteIndex} in the NgModule.${arrayName} of ${className} is not a class`);
         }
         refList.push(entry);
+        absoluteIndex += 1;
       } else {
-        throw createValueHasWrongTypeError(expr, entry, `Value at position ${idx} in the NgModule.${arrayName} of ${className} is not a reference`);
+        throw createValueHasWrongTypeError(expr, entry, `Value at position ${absoluteIndex} in the NgModule.${arrayName} of ${className} is not a reference`);
       }
-    });
-    return refList;
+    }
+    return {
+      references: refList,
+      hasModuleWithProviders
+    };
   }
 };
 function isNgModule(node, compilation) {
-  return !compilation.directives.some((directive) => directive.ref.node === node) && !compilation.pipes.some((pipe) => pipe.ref.node === node);
+  return !compilation.dependencies.some((dep) => dep.ref.node === node);
 }
 function isModuleIdExpression(expr) {
-  return ts22.isPropertyAccessExpression(expr) && ts22.isIdentifier(expr.expression) && expr.expression.text === "module" && expr.name.text === "id";
+  return ts21.isPropertyAccessExpression(expr) && ts21.isIdentifier(expr.expression) && expr.expression.text === "module" && expr.name.text === "id";
+}
+function isResolvedModuleWithProviders(sv) {
+  return typeof sv.value === "object" && sv.value != null && sv.value.hasOwnProperty("ngModule") && sv.value.hasOwnProperty("mwpCall");
+}
+function makeStandaloneBootstrapDiagnostic(ngModuleClass, bootstrappedClassRef, rawBootstrapExpr) {
+  const componentClassName = bootstrappedClassRef.node.name.text;
+  const message = `The \`${componentClassName}\` class is a standalone component, which can not be used in the \`@NgModule.bootstrap\` array. Use the \`bootstrapApplication\` function for bootstrap instead.`;
+  const relatedInformation = [makeRelatedInformation(ngModuleClass, `The 'bootstrap' array is present on this NgModule.`)];
+  return makeDiagnostic(ErrorCode.NGMODULE_BOOTSTRAP_IS_STANDALONE, getDiagnosticNode(bootstrappedClassRef, rawBootstrapExpr), message, relatedInformation);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/diagnostics.mjs
@@ -4849,7 +5128,7 @@ function checkCustomElementSelectorForErrors(selector) {
 
 // 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";
+import ts22 from "typescript";
 function getTemplateDeclarationNodeForError(declaration) {
   switch (declaration.isInline) {
     case true:
@@ -4866,7 +5145,7 @@ function extractTemplate(node, template, evaluator, depTracker, resourceLoader,
     let sourceMapping;
     let escapedString = false;
     let sourceMapUrl;
-    if (ts23.isStringLiteral(template.expression) || ts23.isNoSubstitutionTemplateLiteral(template.expression)) {
+    if (ts22.isStringLiteral(template.expression) || ts22.isNoSubstitutionTemplateLiteral(template.expression)) {
       sourceParseRange = getTemplateRange(template.expression);
       sourceStr = template.expression.getSourceFile().text;
       templateContent = template.expression.text;
@@ -5024,7 +5303,7 @@ function preloadAndParseTemplate(evaluator, resourceLoader, depTracker, preanaly
 }
 function getTemplateRange(templateExpr) {
   const startPos = templateExpr.getStart() + 1;
-  const { line, character } = ts23.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
+  const { line, character } = ts22.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
   return {
     startPos,
     startLine: line,
@@ -5047,27 +5326,38 @@ function makeResourceNotFoundError(file, nodeForError, resourceType) {
   }
   return new FatalDiagnosticError(ErrorCode.COMPONENT_RESOURCE_NOT_FOUND, nodeForError, errorText);
 }
-function transformDecoratorToInlineResources(dec, component, styles, template) {
+function transformDecoratorResources(dec, component, styles, template) {
   if (dec.name !== "Component") {
     return dec;
   }
-  if (!component.has("templateUrl") && !component.has("styleUrls")) {
+  if (!component.has("templateUrl") && !component.has("styleUrls") && !component.has("styles")) {
     return dec;
   }
   const metadata = new Map(component);
   if (metadata.has("templateUrl")) {
     metadata.delete("templateUrl");
-    metadata.set("template", ts23.factory.createStringLiteral(template.content));
+    metadata.set("template", ts22.factory.createStringLiteral(template.content));
   }
-  if (metadata.has("styleUrls")) {
+  if (metadata.has("styleUrls") || metadata.has("styles")) {
+    metadata.delete("styles");
     metadata.delete("styleUrls");
-    metadata.set("styles", ts23.factory.createArrayLiteralExpression(styles.map((s) => ts23.factory.createStringLiteral(s))));
+    if (styles.length > 0) {
+      const styleNodes = styles.reduce((result, style) => {
+        if (style.trim().length > 0) {
+          result.push(ts22.factory.createStringLiteral(style));
+        }
+        return result;
+      }, []);
+      if (styleNodes.length > 0) {
+        metadata.set("styles", ts22.factory.createArrayLiteralExpression(styleNodes));
+      }
+    }
   }
   const newMetadataFields = [];
   for (const [name, value] of metadata.entries()) {
-    newMetadataFields.push(ts23.factory.createPropertyAssignment(name, value));
+    newMetadataFields.push(ts22.factory.createPropertyAssignment(name, value));
   }
-  return __spreadProps(__spreadValues({}, dec), { args: [ts23.factory.createObjectLiteralExpression(newMetadataFields)] });
+  return __spreadProps(__spreadValues({}, dec), { args: [ts22.factory.createObjectLiteralExpression(newMetadataFields)] });
 }
 function extractComponentStyleUrls(evaluator, component) {
   if (!component.has("styleUrls")) {
@@ -5077,9 +5367,9 @@ function extractComponentStyleUrls(evaluator, component) {
 }
 function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
   const styleUrls = [];
-  if (ts23.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (ts22.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const styleUrlExpr of styleUrlsExpr.elements) {
-      if (ts23.isSpreadElement(styleUrlExpr)) {
+      if (ts22.isSpreadElement(styleUrlExpr)) {
         styleUrls.push(...extractStyleUrlsFromExpression(evaluator, styleUrlExpr.expression));
       } else {
         const styleUrl = evaluator.evaluate(styleUrlExpr);
@@ -5111,10 +5401,10 @@ function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
 function extractStyleResources(resourceLoader, component, containingFile) {
   const styles = /* @__PURE__ */ new Set();
   function stringLiteralElements(array) {
-    return array.elements.filter((e) => ts23.isStringLiteralLike(e));
+    return array.elements.filter((e) => ts22.isStringLiteralLike(e));
   }
   const styleUrlsExpr = component.get("styleUrls");
-  if (styleUrlsExpr !== void 0 && ts23.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (styleUrlsExpr !== void 0 && ts22.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const expression of stringLiteralElements(styleUrlsExpr)) {
       try {
         const resourceUrl = resourceLoader.resolve(expression.text, containingFile);
@@ -5124,7 +5414,7 @@ function extractStyleResources(resourceLoader, component, containingFile) {
     }
   }
   const stylesExpr = component.get("styles");
-  if (stylesExpr !== void 0 && ts23.isArrayLiteralExpression(stylesExpr)) {
+  if (stylesExpr !== void 0 && ts22.isArrayLiteralExpression(stylesExpr)) {
     for (const expression of stringLiteralElements(stylesExpr)) {
       styles.add({ path: null, expression });
     }
@@ -5139,112 +5429,6 @@ function _extractTemplateStyleUrls(template) {
   return template.styleUrls.map((url) => ({ url, source: 1, nodeForError }));
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/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;
-        }
-      }
-      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 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/component/src/symbol.mjs
 var ComponentSymbol = class extends DirectiveSymbol {
   constructor() {
@@ -5281,7 +5465,6 @@ var ComponentSymbol = class extends DirectiveSymbol {
 };
 
 // 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");
@@ -5301,19 +5484,18 @@ function collectAnimationNames(value, animationTriggerNames) {
 function isAngularAnimationsReference(reference, symbolName) {
   return reference.ownedByModuleGuess === "@angular/animations" && reference.debugName === symbolName;
 }
-var animationTriggerResolver = (ref, args) => {
+var animationTriggerResolver = (fn, node, resolve, unresolvable) => {
   const animationTriggerMethodName = "trigger";
-  if (!isAngularAnimationsReference(ref, animationTriggerMethodName)) {
-    return null;
+  if (!isAngularAnimationsReference(fn, animationTriggerMethodName)) {
+    return unresolvable;
   }
-  const triggerNameExpression = args[0];
+  const triggerNameExpression = node.arguments[0];
   if (!triggerNameExpression) {
-    return null;
+    return unresolvable;
   }
-  const factory = ts24.factory;
-  return factory.createObjectLiteralExpression([
-    factory.createPropertyAssignment(factory.createIdentifier("name"), triggerNameExpression)
-  ], true);
+  const res = /* @__PURE__ */ new Map();
+  res.set("name", resolve(triggerNameExpression));
+  return res;
 };
 function validateAndFlattenComponentImports(imports, expr) {
   const flattened = [];
@@ -5344,7 +5526,6 @@ function validateAndFlattenComponentImports(imports, expr) {
 }
 
 // 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, dtsScopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf) {
@@ -5484,20 +5665,20 @@ var ComponentDecoratorHandler = class {
     if (component.has("providers")) {
       providersRequiringFactory = resolveProvidersRequiringFactory(component.get("providers"), this.reflector, this.evaluator);
     }
-    let imports = null;
+    let resolvedImports = null;
+    let rawImports = 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.`));
+      diagnostics.push(makeDiagnostic(ErrorCode.COMPONENT_NOT_STANDALONE, component.get("imports"), `'imports' is only valid on a component that is standalone.`, [makeRelatedInformation(node.name, `Did you forget to add 'standalone: true' to this @Component?`)]));
+      isPoisoned = true;
     } else if (component.has("imports")) {
       const expr = component.get("imports");
-      const imported = this.evaluator.evaluate(expr);
+      const imported = this.evaluator.evaluate(expr, forwardRefResolver);
       const { imports: flattened, diagnostics: importDiagnostics } = validateAndFlattenComponentImports(imported, expr);
-      imports = {
-        resolved: flattened,
-        raw: expr
-      };
+      resolvedImports = flattened;
+      rawImports = expr;
       if (importDiagnostics.length > 0) {
         isPoisoned = true;
         if (diagnostics === void 0) {
@@ -5506,6 +5687,17 @@ var ComponentDecoratorHandler = class {
         diagnostics.push(...importDiagnostics);
       }
     }
+    let schemas = null;
+    if (component.has("schemas") && !metadata.isStandalone) {
+      if (diagnostics === void 0) {
+        diagnostics = [];
+      }
+      diagnostics.push(makeDiagnostic(ErrorCode.COMPONENT_NOT_STANDALONE, component.get("schemas"), `'schemas' is only valid on a component that is standalone.`));
+    } else if (component.has("schemas")) {
+      schemas = extractSchemas(component.get("schemas"), this.evaluator, "Component");
+    } else if (metadata.isStandalone) {
+      schemas = [];
+    }
     let template;
     if (this.preanalyzeTemplateCache.has(node)) {
       const preanalyzed = this.preanalyzeTemplateCache.get(node);
@@ -5595,7 +5787,7 @@ var ComponentDecoratorHandler = class {
           relativeContextFilePath
         }),
         typeCheckMeta: extractDirectiveTypeCheckMeta(node, inputs, this.reflector),
-        classMetadata: extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorToInlineResources(dec, component, styles, template)),
+        classMetadata: extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorResources(dec, component, styles, template)),
         template,
         providersRequiringFactory,
         viewProvidersRequiringFactory,
@@ -5607,7 +5799,9 @@ var ComponentDecoratorHandler = class {
         },
         isPoisoned,
         animationTriggerNames,
-        imports
+        rawImports,
+        resolvedImports,
+        schemas
       },
       diagnostics
     };
@@ -5623,7 +5817,7 @@ var ComponentDecoratorHandler = class {
   register(node, analysis) {
     const ref = new Reference(node);
     this.metaRegistry.registerDirectiveMetadata(__spreadProps(__spreadValues({
-      type: MetaType.Directive,
+      kind: MetaKind.Directive,
       ref,
       name: node.name.text,
       selector: analysis.meta.selector,
@@ -5637,7 +5831,9 @@ var ComponentDecoratorHandler = class {
       isPoisoned: analysis.isPoisoned,
       isStructural: false,
       isStandalone: analysis.meta.isStandalone,
-      animationTriggerNames: analysis.animationTriggerNames
+      imports: analysis.resolvedImports,
+      animationTriggerNames: analysis.animationTriggerNames,
+      schemas: analysis.schemas
     }));
     this.resourceRegistry.registerResources(analysis.resources, node);
     this.injectableRegistry.registerInjectable(node);
@@ -5648,14 +5844,15 @@ var ComponentDecoratorHandler = class {
     }
     const scope = this.scopeReader.getScopeForComponent(node);
     const selector = analysis.meta.selector;
-    const matcher = new SelectorMatcher();
+    const matcher = new SelectorMatcher2();
     if (scope !== null) {
-      if ((scope.compilation.isPoisoned || scope.exported.isPoisoned) && !this.usePoisonedData) {
+      let { dependencies, isPoisoned } = scope.kind === ComponentScopeKind.NgModule ? scope.compilation : scope;
+      if ((isPoisoned || scope.kind === ComponentScopeKind.NgModule && scope.exported.isPoisoned) && !this.usePoisonedData) {
         return null;
       }
-      for (const directive of scope.compilation.directives) {
-        if (directive.selector !== null) {
-          matcher.addSelectables(CssSelector.parse(directive.selector), directive);
+      for (const dep of dependencies) {
+        if (dep.kind === MetaKind.Directive && dep.selector !== null) {
+          matcher.addSelectables(CssSelector2.parse(dep.selector), dep);
         }
       }
     }
@@ -5672,7 +5869,7 @@ var ComponentDecoratorHandler = class {
     });
   }
   typeCheck(ctx, node, meta) {
-    if (this.typeCheckScopeRegistry === null || !ts25.isClassDeclaration(node)) {
+    if (this.typeCheckScopeRegistry === null || !ts23.isClassDeclaration(node)) {
       return;
     }
     if (meta.isPoisoned && !this.usePoisonedData) {
@@ -5698,90 +5895,120 @@ var ComponentDecoratorHandler = class {
     const context = getSourceFile(node);
     const metadata = analysis.meta;
     const data = {
-      directives: EMPTY_ARRAY,
-      pipes: EMPTY_MAP,
+      declarations: EMPTY_ARRAY,
       declarationListEmitMode: 0
     };
     const diagnostics = [];
-    const scope = scopeTemplate(this.scopeReader, this.dtsScopeReader, this.scopeRegistry, this.metaReader, node, analysis, this.usePoisonedData);
+    const scope = this.scopeReader.getScopeForComponent(node);
     if (scope !== null) {
-      diagnostics.push(...scope.diagnostics);
-      const matcher = new SelectorMatcher();
-      for (const dir of scope.directives) {
-        if (dir.selector !== null) {
-          matcher.addSelectables(CssSelector.parse(dir.selector), dir);
-        }
-      }
+      const matcher = new SelectorMatcher2();
       const pipes = /* @__PURE__ */ new Map();
-      for (const pipe of scope.pipes) {
-        pipes.set(pipe.name, pipe.ref);
+      const dependencies = scope.kind === ComponentScopeKind.NgModule ? scope.compilation.dependencies : scope.dependencies;
+      for (const dep of dependencies) {
+        if (dep.kind === MetaKind.Directive && dep.selector !== null) {
+          matcher.addSelectables(CssSelector2.parse(dep.selector), dep);
+        } else if (dep.kind === MetaKind.Pipe) {
+          pipes.set(dep.name, dep);
+        }
       }
       const binder = new R3TargetBinder(matcher);
       const bound = binder.bind({ template: metadata.template.nodes });
-      const usedDirectives = bound.getUsedDirectives().map((directive) => {
-        const type = this.refEmitter.emit(directive.ref, context);
-        assertSuccessfulReferenceEmit(type, node.name, directive.isComponent ? "component" : "directive");
-        return {
-          ref: directive.ref,
-          type: type.expression,
-          importedFile: type.importedFile,
-          selector: directive.selector,
-          inputs: directive.inputs.propertyNames,
-          outputs: directive.outputs.propertyNames,
-          exportAs: directive.exportAs,
-          isComponent: directive.isComponent
-        };
-      });
-      const usedPipes = [];
-      for (const pipeName of bound.getUsedPipes()) {
-        if (!pipes.has(pipeName)) {
+      const used = /* @__PURE__ */ new Set();
+      for (const dir of bound.getUsedDirectives()) {
+        used.add(dir.ref.node);
+      }
+      for (const name of bound.getUsedPipes()) {
+        if (!pipes.has(name)) {
           continue;
         }
-        const pipe = pipes.get(pipeName);
-        const type = this.refEmitter.emit(pipe, context);
-        assertSuccessfulReferenceEmit(type, node.name, "pipe");
-        usedPipes.push({
-          ref: pipe,
-          pipeName,
-          expression: type.expression,
-          importedFile: type.importedFile
-        });
+        used.add(pipes.get(name).ref.node);
+      }
+      const declarations = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const dep of dependencies) {
+        if (seen.has(dep.ref.node)) {
+          continue;
+        }
+        seen.add(dep.ref.node);
+        switch (dep.kind) {
+          case MetaKind.Directive:
+            if (!used.has(dep.ref.node)) {
+              continue;
+            }
+            const dirType = this.refEmitter.emit(dep.ref, context);
+            assertSuccessfulReferenceEmit(dirType, node.name, dep.isComponent ? "component" : "directive");
+            declarations.push({
+              kind: R3TemplateDependencyKind.Directive,
+              ref: dep.ref,
+              type: dirType.expression,
+              importedFile: dirType.importedFile,
+              selector: dep.selector,
+              inputs: dep.inputs.propertyNames,
+              outputs: dep.outputs.propertyNames,
+              exportAs: dep.exportAs,
+              isComponent: dep.isComponent
+            });
+            break;
+          case MetaKind.Pipe:
+            if (!used.has(dep.ref.node)) {
+              continue;
+            }
+            const pipeType = this.refEmitter.emit(dep.ref, context);
+            assertSuccessfulReferenceEmit(pipeType, node.name, "pipe");
+            declarations.push({
+              kind: R3TemplateDependencyKind.Pipe,
+              type: pipeType.expression,
+              name: dep.name,
+              ref: dep.ref,
+              importedFile: pipeType.importedFile
+            });
+            break;
+          case MetaKind.NgModule:
+            const ngModuleType = this.refEmitter.emit(dep.ref, context);
+            assertSuccessfulReferenceEmit(ngModuleType, node.name, "NgModule");
+            declarations.push({
+              kind: R3TemplateDependencyKind.NgModule,
+              type: ngModuleType.expression,
+              importedFile: ngModuleType.importedFile
+            });
+            break;
+        }
       }
+      const isUsedDirective = (decl) => decl.kind === R3TemplateDependencyKind.Directive;
+      const isUsedPipe = (decl) => decl.kind === R3TemplateDependencyKind.Pipe;
+      const getSemanticReference = (decl) => this.semanticDepGraphUpdater.getSemanticReference(decl.ref.node, decl.type);
       if (this.semanticDepGraphUpdater !== null) {
-        symbol.usedDirectives = usedDirectives.map((dir) => this.semanticDepGraphUpdater.getSemanticReference(dir.ref.node, dir.type));
-        symbol.usedPipes = usedPipes.map((pipe) => this.semanticDepGraphUpdater.getSemanticReference(pipe.ref.node, pipe.expression));
+        symbol.usedDirectives = declarations.filter(isUsedDirective).map(getSemanticReference);
+        symbol.usedPipes = declarations.filter(isUsedPipe).map(getSemanticReference);
       }
       const cyclesFromDirectives = /* @__PURE__ */ new Map();
-      for (const usedDirective of usedDirectives) {
-        const cycle = this._checkForCyclicImport(usedDirective.importedFile, usedDirective.type, context);
-        if (cycle !== null) {
-          cyclesFromDirectives.set(usedDirective, cycle);
-        }
-      }
       const cyclesFromPipes = /* @__PURE__ */ new Map();
-      for (const usedPipe of usedPipes) {
-        const cycle = this._checkForCyclicImport(usedPipe.importedFile, usedPipe.expression, context);
+      for (const usedDep of declarations) {
+        const cycle = this._checkForCyclicImport(usedDep.importedFile, usedDep.type, context);
         if (cycle !== null) {
-          cyclesFromPipes.set(usedPipe, cycle);
+          switch (usedDep.kind) {
+            case R3TemplateDependencyKind.Directive:
+              cyclesFromDirectives.set(usedDep, cycle);
+              break;
+            case R3TemplateDependencyKind.Pipe:
+              cyclesFromPipes.set(usedDep, cycle);
+              break;
+          }
         }
       }
       const cycleDetected = cyclesFromDirectives.size !== 0 || cyclesFromPipes.size !== 0;
       if (!cycleDetected) {
-        for (const { type, importedFile } of usedDirectives) {
+        for (const { type, importedFile } of declarations) {
           this._recordSyntheticImport(importedFile, type, context);
         }
-        for (const { expression, importedFile } of usedPipes) {
-          this._recordSyntheticImport(importedFile, expression, context);
-        }
-        const wrapDirectivesAndPipesInClosure = usedDirectives.some((dir) => isExpressionForwardReference(dir.type, node.name, context)) || usedPipes.some((pipe) => isExpressionForwardReference(pipe.expression, node.name, context));
-        data.directives = usedDirectives;
-        data.pipes = new Map(usedPipes.map((pipe) => [pipe.pipeName, pipe.expression]));
+        const wrapDirectivesAndPipesInClosure = declarations.some((decl) => isExpressionForwardReference(decl.type, node.name, context));
+        data.declarations = declarations;
         data.declarationListEmitMode = wrapDirectivesAndPipesInClosure ? 1 : 0;
       } else {
         if (this.cycleHandlingStrategy === 0) {
-          this.scopeRegistry.setComponentRemoteScope(node, usedDirectives.map((dir) => dir.ref), usedPipes.map((pipe) => pipe.ref));
+          this.scopeRegistry.setComponentRemoteScope(node, declarations.filter(isUsedDirective).map((dir) => dir.ref), declarations.filter(isUsedPipe).map((pipe) => pipe.ref));
           symbol.isRemotelyScoped = true;
-          if (this.semanticDepGraphUpdater !== null && scope.ngModule !== null) {
+          if (this.semanticDepGraphUpdater !== null && scope.kind === ComponentScopeKind.NgModule && 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.`);
@@ -5800,6 +6027,10 @@ var ComponentDecoratorHandler = class {
         }
       }
     }
+    if (analysis.resolvedImports !== null && analysis.rawImports !== null) {
+      const standaloneDiagnostics = validateStandaloneImports(analysis.resolvedImports, analysis.rawImports, this.metaReader, this.scopeReader);
+      diagnostics.push(...standaloneDiagnostics);
+    }
     if (analysis.providersRequiringFactory !== null && analysis.meta.providers instanceof WrappedNodeExpr7) {
       const providerDiagnostics = getProviderDiagnostics(analysis.providersRequiringFactory, analysis.meta.providers.node, this.injectableRegistry);
       diagnostics.push(...providerDiagnostics);
@@ -5846,7 +6077,7 @@ var ComponentDecoratorHandler = class {
     for (const styleText of analysis.template.styles) {
       styles.push(styleText);
     }
-    analysis.meta.styles = styles;
+    analysis.meta.styles = styles.filter((s) => s.trim().length > 0);
   }
   compileFull(node, analysis, resolution, pool) {
     if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
@@ -5889,10 +6120,35 @@ var ComponentDecoratorHandler = class {
     this.cycleAnalyzer.recordSyntheticImport(origin, imported);
   }
 };
+function validateStandaloneImports(importRefs, importExpr, metaReader, scopeReader) {
+  const diagnostics = [];
+  for (const ref of importRefs) {
+    const dirMeta = metaReader.getDirectiveMetadata(ref);
+    if (dirMeta !== null) {
+      if (!dirMeta.isStandalone) {
+        diagnostics.push(makeNotStandaloneDiagnostic(scopeReader, ref, importExpr, dirMeta.isComponent ? "component" : "directive"));
+      }
+      continue;
+    }
+    const pipeMeta = metaReader.getPipeMetadata(ref);
+    if (pipeMeta !== null) {
+      if (!pipeMeta.isStandalone) {
+        diagnostics.push(makeNotStandaloneDiagnostic(scopeReader, ref, importExpr, "pipe"));
+      }
+      continue;
+    }
+    const ngModuleMeta = metaReader.getNgModuleMetadata(ref);
+    if (ngModuleMeta !== null) {
+      continue;
+    }
+    diagnostics.push(makeUnknownComponentImportDiagnostic(ref, importExpr));
+  }
+  return diagnostics;
+}
 
 // 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 WrappedNodeExpr8 } from "@angular/compiler";
-import ts26 from "typescript";
+import ts24 from "typescript";
 var InjectableDecoratorHandler = class {
   constructor(reflector, isCore, strictCtorDeps, injectableRegistry, perf, errorOnDuplicateProv = true) {
     this.reflector = reflector;
@@ -5983,7 +6239,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     };
   } else if (decorator.args.length === 1) {
     const metaNode = decorator.args[0];
-    if (!ts26.isObjectLiteralExpression(metaNode)) {
+    if (!ts24.isObjectLiteralExpression(metaNode)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, metaNode, `@Injectable argument must be an object literal`);
     }
     const meta = reflectObjectLiteral(metaNode);
@@ -5991,7 +6247,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 (!ts26.isArrayLiteralExpression(depsExpr)) {
+      if (!ts24.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));
@@ -6073,12 +6329,12 @@ function getDep(dep, reflector) {
     }
     return true;
   }
-  if (ts26.isArrayLiteralExpression(dep)) {
+  if (ts24.isArrayLiteralExpression(dep)) {
     dep.elements.forEach((el) => {
       let isDecorator = false;
-      if (ts26.isIdentifier(el)) {
+      if (ts24.isIdentifier(el)) {
         isDecorator = maybeUpdateDecorator(el, reflector);
-      } else if (ts26.isNewExpression(el) && ts26.isIdentifier(el.expression)) {
+      } else if (ts24.isNewExpression(el) && ts24.isIdentifier(el.expression)) {
         const token = el.arguments && el.arguments.length > 0 && el.arguments[0] || void 0;
         isDecorator = maybeUpdateDecorator(el.expression, reflector, token);
       }
@@ -6092,7 +6348,7 @@ 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 WrappedNodeExpr9 } from "@angular/compiler";
-import ts27 from "typescript";
+import ts25 from "typescript";
 var PipeSymbol = class extends SemanticSymbol {
   constructor(decl, name) {
     super(decl);
@@ -6147,7 +6403,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 (!ts27.isObjectLiteralExpression(meta)) {
+    if (!ts25.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@Pipe must have a literal argument");
     }
     const pipe = reflectObjectLiteral(meta);
@@ -6195,12 +6451,12 @@ var PipeDecoratorHandler = class {
     };
   }
   symbol(node, analysis) {
-    return new PipeSymbol(node, analysis.meta.name);
+    return new PipeSymbol(node, analysis.meta.pipeName);
   }
   register(node, analysis) {
     const ref = new Reference(node);
     this.metaRegistry.registerPipeMetadata({
-      type: MetaType.Pipe,
+      kind: MetaKind.Pipe,
       ref,
       name: analysis.meta.pipeName,
       nameExpr: analysis.pipeNameExpr,
@@ -6239,25 +6495,21 @@ export {
   PartialEvaluator,
   NoopReferencesRegistry,
   SemanticDepGraphUpdater,
+  MetaKind,
   CompoundMetadataReader,
   DtsMetadataReader,
-  flattenInheritedDirectiveMetadata,
   LocalMetadataRegistry,
   CompoundMetadataRegistry,
   InjectableClassRegistry,
   ResourceRegistry,
+  ComponentScopeKind,
+  CompoundComponentScopeReader,
+  MetadataDtsModuleScopeResolver,
+  LocalModuleScopeRegistry,
+  TypeCheckScopeRegistry,
   CompilationMode,
   HandlerFlags,
   aliasTransformFactory,
-  isShim,
-  copyFileShimData,
-  untagAllTsFiles,
-  retagAllTsFiles,
-  ShimAdapter,
-  FactoryGenerator,
-  generatedFactoryTransform,
-  ShimReferenceTagger,
-  SummaryGenerator,
   TraitState,
   TraitCompiler,
   DtsTransformRegistry,
@@ -6276,5 +6528,4 @@ export {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-// Closure Compiler ignores @suppress and similar if the comment contains @license.
-//# sourceMappingURL=chunk-GYVY4Y2L.js.map
+//# sourceMappingURL=chunk-GJVJ6GH4.js.map