@angular/compiler-cli 21.0.0-next.8 → 21.0.0-rc.0

package/bundles/{chunk-NBFYHUMW.js → chunk-ZOZ6XVF3.js}

@@ -2,9 +2,6 @@
       import {createRequire as __cjsCompatRequire} from 'module';
       const require = __cjsCompatRequire(import.meta.url);
     
-import {
-  angularJitApplicationTransform
-} from "./chunk-WXJFCHPN.js";
 import {
   AbsoluteModuleStrategy,
   ActivePerfRecorder,
@@ -66,13 +63,13 @@ import {
   SymbolKind,
   TemplateTypeCheckerImpl,
   TraitCompiler,
-  TsCreateProgramDriver,
   TypeCheckScopeRegistry,
   TypeCheckShimGenerator,
   TypeScriptReflectionHost,
   UnifiedModulesAliasingHost,
   UnifiedModulesStrategy,
   aliasTransformFactory,
+  angularJitApplicationTransform,
   declarationTransformFactory,
   getRootDirs,
   getSourceFileOrNull,
@@ -86,52 +83,20 @@ import {
   ngErrorCode,
   normalizeSeparators,
   relativePathBetween,
-  replaceTsWithNgInErrors,
-  retagAllTsFiles,
   signalMetadataTransform,
   toUnredirectedSourceFile,
   tryParseInitializerApi,
   untagAllTsFiles
-} from "./chunk-ELPMV5DB.js";
+} from "./chunk-3CWKYDQ7.js";
 import {
   LogicalFileSystem,
-  absoluteFrom,
   absoluteFromSourceFile,
-  createFileSystemTsReadDirectoryFn,
   dirname,
   getFileSystem,
   join,
   resolve
 } from "./chunk-GWZQLAGK.js";
 
-// packages/compiler-cli/src/transformers/api.js
-var DEFAULT_ERROR_CODE = 100;
-var UNKNOWN_ERROR_CODE = 500;
-var SOURCE = "angular";
-function isTsDiagnostic(diagnostic) {
-  return diagnostic != null && diagnostic.source !== "angular";
-}
-var EmitFlags;
-(function(EmitFlags2) {
-  EmitFlags2[EmitFlags2["DTS"] = 1] = "DTS";
-  EmitFlags2[EmitFlags2["JS"] = 2] = "JS";
-  EmitFlags2[EmitFlags2["Metadata"] = 4] = "Metadata";
-  EmitFlags2[EmitFlags2["I18nBundle"] = 8] = "I18nBundle";
-  EmitFlags2[EmitFlags2["Codegen"] = 16] = "Codegen";
-  EmitFlags2[EmitFlags2["Default"] = 19] = "Default";
-  EmitFlags2[EmitFlags2["All"] = 31] = "All";
-})(EmitFlags || (EmitFlags = {}));
-
-// packages/compiler-cli/src/transformers/compiler_host.js
-import ts from "typescript";
-var wrapHostForTest = null;
-function createCompilerHost({ options, tsHost = ts.createCompilerHost(options, true) }) {
-  if (wrapHostForTest !== null) {
-    tsHost = wrapHostForTest(tsHost);
-  }
-  return tsHost;
-}
-
 // packages/compiler-cli/src/ngtsc/docs/src/entities.js
 var EntryType;
 (function(EntryType2) {
@@ -180,62 +145,44 @@ function isDocEntryWithSourceInfo(entry) {
 }
 
 // packages/compiler-cli/src/ngtsc/docs/src/extractor.js
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/docs/src/class_extractor.js
 import ts6 from "typescript";
 
-// packages/compiler-cli/src/ngtsc/docs/src/filters.js
-function isAngularPrivateName(name) {
-  const firstChar = name[0] ?? "";
-  return firstChar === "\u0275" || firstChar === "_";
-}
-
-// packages/compiler-cli/src/ngtsc/docs/src/function_extractor.js
-import ts4 from "typescript";
-
-// packages/compiler-cli/src/ngtsc/docs/src/generics_extractor.js
-function extractGenerics(declaration) {
-  return declaration.typeParameters?.map((typeParam) => ({
-    name: typeParam.name.getText(),
-    constraint: typeParam.constraint?.getText(),
-    default: typeParam.default?.getText()
-  })) ?? [];
-}
-
 // packages/compiler-cli/src/ngtsc/docs/src/jsdoc_extractor.js
-import ts2 from "typescript";
+import ts from "typescript";
 var decoratorExpression = /@(?=(Injectable|Component|Directive|Pipe|NgModule|Input|Output|HostBinding|HostListener|Inject|Optional|Self|Host|SkipSelf|ViewChild|ViewChildren|ContentChild|ContentChildren))/g;
 function extractJsDocTags(node) {
   const escapedNode = getEscapedNode(node);
-  return ts2.getJSDocTags(escapedNode).map((t) => {
+  return ts.getJSDocTags(escapedNode).map((t) => {
     return {
       name: t.tagName.getText(),
-      comment: unescapeAngularDecorators(ts2.getTextOfJSDocComment(t.comment) ?? "")
+      comment: unescapeAngularDecorators(ts.getTextOfJSDocComment(t.comment) ?? "")
     };
   });
 }
 function extractJsDocDescription(node) {
   const escapedNode = getEscapedNode(node);
-  const commentOrTag = ts2.getJSDocCommentsAndTags(escapedNode).find((d) => {
-    return ts2.isJSDoc(d) || ts2.isJSDocParameterTag(d);
+  const commentOrTag = ts.getJSDocCommentsAndTags(escapedNode).find((d) => {
+    return ts.isJSDoc(d) || ts.isJSDocParameterTag(d);
   });
   const comment = commentOrTag?.comment ?? "";
-  const description = typeof comment === "string" ? comment : ts2.getTextOfJSDocComment(comment) ?? "";
+  const description = typeof comment === "string" ? comment : ts.getTextOfJSDocComment(comment) ?? "";
   return unescapeAngularDecorators(description);
 }
 function extractRawJsDoc(node) {
-  const comment = ts2.getJSDocCommentsAndTags(node).find(ts2.isJSDoc)?.getFullText() ?? "";
+  const comment = ts.getJSDocCommentsAndTags(node).find(ts.isJSDoc)?.getFullText() ?? "";
   return unescapeAngularDecorators(comment);
 }
 function getEscapedNode(node) {
-  if (ts2.isParameter(node)) {
+  if (ts.isParameter(node)) {
     return node;
   }
   const rawComment = extractRawJsDoc(node);
   const escaped = escapeAngularDecorators(rawComment);
-  const file = ts2.createSourceFile("x.ts", `${escaped}class X {}`, ts2.ScriptTarget.ES2020, true);
-  return file.statements.find((s) => ts2.isClassDeclaration(s));
+  const file = ts.createSourceFile("x.ts", `${escaped}class X {}`, ts.ScriptTarget.ES2020, true);
+  return file.statements.find((s) => ts.isClassDeclaration(s));
 }
 function escapeAngularDecorators(comment) {
   return comment.replace(decoratorExpression, "_NG_AT_");
@@ -244,10 +191,31 @@ function unescapeAngularDecorators(comment) {
   return comment.replace(/_NG_AT_/g, "@");
 }
 
-// packages/compiler-cli/src/ngtsc/docs/src/type_extractor.js
+// packages/compiler-cli/src/ngtsc/docs/src/properties_extractor.js
+import ts5 from "typescript";
+
+// packages/compiler-cli/src/ngtsc/docs/src/filters.js
+function isAngularPrivateName(name) {
+  const firstChar = name[0] ?? "";
+  return firstChar === "\u0275" || firstChar === "_";
+}
+
+// packages/compiler-cli/src/ngtsc/docs/src/function_extractor.js
 import ts3 from "typescript";
+
+// packages/compiler-cli/src/ngtsc/docs/src/generics_extractor.js
+function extractGenerics(declaration) {
+  return declaration.typeParameters?.map((typeParam) => ({
+    name: typeParam.name.getText(),
+    constraint: typeParam.constraint?.getText(),
+    default: typeParam.default?.getText()
+  })) ?? [];
+}
+
+// packages/compiler-cli/src/ngtsc/docs/src/type_extractor.js
+import ts2 from "typescript";
 function extractResolvedTypeString(node, checker) {
-  return checker.typeToString(checker.getTypeAtLocation(node), void 0, ts3.TypeFormatFlags.NoTruncation);
+  return checker.typeToString(checker.getTypeAtLocation(node), void 0, ts2.TypeFormatFlags.NoTruncation);
 }
 
 // packages/compiler-cli/src/ngtsc/docs/src/function_extractor.js
@@ -265,7 +233,7 @@ var FunctionExtractor = class {
     const returnType = signature ? extractReturnType(signature, this.typeChecker) : "unknown";
     const implementation = findImplementationOfFunction(this.exportDeclaration, this.typeChecker) ?? this.exportDeclaration;
     const type = this.typeChecker.getTypeAtLocation(this.exportDeclaration);
-    const overloads = ts4.isConstructorDeclaration(this.exportDeclaration) ? constructorOverloads(this.exportDeclaration, this.typeChecker) : extractCallSignatures(this.name, this.typeChecker, type);
+    const overloads = ts3.isConstructorDeclaration(this.exportDeclaration) ? constructorOverloads(this.exportDeclaration, this.typeChecker) : extractCallSignatures(this.name, this.typeChecker, type);
     const jsdocsTags = extractJsDocTags(implementation);
     const description = extractJsDocDescription(implementation);
     return {
@@ -273,7 +241,7 @@ var FunctionExtractor = class {
       signatures: overloads,
       implementation: {
         params: extractAllParams(implementation.parameters, this.typeChecker),
-        isNewType: ts4.isConstructSignatureDeclaration(implementation),
+        isNewType: ts3.isConstructSignatureDeclaration(implementation),
         returnType,
         returnDescription: jsdocsTags.find((tag) => tag.name === "returns")?.comment,
         generics: extractGenerics(implementation),
@@ -293,7 +261,7 @@ var FunctionExtractor = class {
 function constructorOverloads(constructorDeclaration, typeChecker) {
   const classDeclaration = constructorDeclaration.parent;
   const constructorNode = classDeclaration.members.filter((member) => {
-    return ts4.isConstructorDeclaration(member) && !member.body;
+    return ts3.isConstructorDeclaration(member) && !member.body;
   });
   return constructorNode.map((n) => {
     return {
@@ -322,7 +290,7 @@ function filterSignatureDeclarations(signatures) {
   const result = [];
   for (const signature of signatures) {
     const decl = signature.getDeclaration();
-    if (ts4.isFunctionDeclaration(decl) || ts4.isCallSignatureDeclaration(decl) || ts4.isMethodDeclaration(decl) || ts4.isConstructSignatureDeclaration(decl)) {
+    if (ts3.isFunctionDeclaration(decl) || ts3.isCallSignatureDeclaration(decl) || ts3.isMethodDeclaration(decl) || ts3.isConstructSignatureDeclaration(decl)) {
       result.push({ signature, decl });
     }
   }
@@ -342,14 +310,14 @@ function extractCallSignatures(name, typeChecker, type) {
   }));
 }
 function extractReturnType(signature, typeChecker) {
-  if (signature?.declaration?.type && ts4.isTypePredicateNode(signature.declaration.type)) {
+  if (signature?.declaration?.type && ts3.isTypePredicateNode(signature.declaration.type)) {
     return signature.declaration.type.getText();
   }
   return typeChecker.typeToString(
     typeChecker.getReturnTypeOfSignature(signature),
     void 0,
     // This ensures that e.g. `T | undefined` is not reduced to `T`.
-    ts4.TypeFormatFlags.NoTypeReduction | ts4.TypeFormatFlags.NoTruncation
+    ts3.TypeFormatFlags.NoTypeReduction | ts3.TypeFormatFlags.NoTruncation
   );
 }
 function findImplementationOfFunction(node, typeChecker) {
@@ -357,18 +325,18 @@ function findImplementationOfFunction(node, typeChecker) {
     return node;
   }
   const symbol = typeChecker.getSymbolAtLocation(node.name);
-  const implementation = symbol?.declarations?.find((s) => ts4.isFunctionDeclaration(s) && s.body !== void 0);
+  const implementation = symbol?.declarations?.find((s) => ts3.isFunctionDeclaration(s) && s.body !== void 0);
   return implementation;
 }
 
 // packages/compiler-cli/src/ngtsc/docs/src/internal.js
-import ts5 from "typescript";
+import ts4 from "typescript";
 function isInternal(member) {
   return extractJsDocTags(member).some((tag) => tag.name === "internal") || hasLeadingInternalComment(member);
 }
 function hasLeadingInternalComment(member) {
   const memberText = member.getSourceFile().text;
-  return ts5.reduceEachLeadingCommentRange(
+  return ts4.reduceEachLeadingCommentRange(
     memberText,
     member.getFullStart(),
     (pos, end, kind, hasTrailingNewLine, containsInternal) => {
@@ -381,8 +349,8 @@ function hasLeadingInternalComment(member) {
   ) ?? false;
 }
 
-// packages/compiler-cli/src/ngtsc/docs/src/class_extractor.js
-var ClassExtractor = class {
+// packages/compiler-cli/src/ngtsc/docs/src/properties_extractor.js
+var PropertiesExtractor = class {
   declaration;
   typeChecker;
   constructor(declaration, typeChecker) {
@@ -392,16 +360,8 @@ var ClassExtractor = class {
   /** Extract docs info specific to classes. */
   extract() {
     return {
-      name: this.declaration.name.text,
-      isAbstract: this.isAbstract(),
-      entryType: ts6.isInterfaceDeclaration(this.declaration) ? EntryType.Interface : EntryType.UndecoratedClass,
       members: this.extractSignatures().concat(this.extractAllClassMembers()),
-      generics: extractGenerics(this.declaration),
-      description: extractJsDocDescription(this.declaration),
-      jsdocTags: extractJsDocTags(this.declaration),
-      rawComment: extractRawJsDoc(this.declaration),
-      extends: this.extractInheritance(this.declaration),
-      implements: this.extractInterfaceConformance(this.declaration)
+      generics: extractGenerics(this.declaration)
     };
   }
   /** Extracts doc info for a class's members. */
@@ -423,9 +383,9 @@ var ClassExtractor = class {
       return this.extractMethod(memberDeclaration);
     } else if (this.isProperty(memberDeclaration) && !this.hasPrivateComputedProperty(memberDeclaration)) {
       return this.extractClassProperty(memberDeclaration);
-    } else if (ts6.isAccessor(memberDeclaration)) {
+    } else if (ts5.isAccessor(memberDeclaration)) {
       return this.extractGetterSetter(memberDeclaration);
-    } else if (ts6.isConstructorDeclaration(memberDeclaration) && memberDeclaration.parameters.length > 0) {
+    } else if (ts5.isConstructorDeclaration(memberDeclaration) && memberDeclaration.parameters.length > 0) {
       return this.extractConstructor(memberDeclaration);
     }
     return void 0;
@@ -445,7 +405,7 @@ var ClassExtractor = class {
   }
   /** Extracts docs for a signature element (usually inside an interface). */
   extractSignature(signature) {
-    const functionExtractor = new FunctionExtractor(ts6.isConstructSignatureDeclaration(signature) ? "new" : "", signature, this.typeChecker);
+    const functionExtractor = new FunctionExtractor(ts5.isConstructSignatureDeclaration(signature) ? "new" : "", signature, this.typeChecker);
     return {
       ...functionExtractor.extract(),
       memberType: MemberType.Method,
@@ -467,7 +427,7 @@ var ClassExtractor = class {
   extractGetterSetter(accessor) {
     return {
       ...this.extractClassProperty(accessor),
-      memberType: ts6.isGetAccessor(accessor) ? MemberType.Getter : MemberType.Setter
+      memberType: ts5.isGetAccessor(accessor) ? MemberType.Getter : MemberType.Setter
     };
   }
   extractConstructor(constructorDeclaration) {
@@ -478,23 +438,8 @@ var ClassExtractor = class {
       memberTags: this.getMemberTags(constructorDeclaration)
     };
   }
-  extractInheritance(declaration) {
-    if (!declaration.heritageClauses) {
-      return void 0;
-    }
-    for (const clause of declaration.heritageClauses) {
-      if (clause.token === ts6.SyntaxKind.ExtendsKeyword) {
-        const types = clause.types;
-        if (types.length > 0) {
-          const baseClass = types[0];
-          return baseClass.getText();
-        }
-      }
-    }
-    return void 0;
-  }
   extractInterfaceConformance(declaration) {
-    const implementClause = declaration.heritageClauses?.find((clause) => clause.token === ts6.SyntaxKind.ImplementsKeyword);
+    const implementClause = declaration.heritageClauses?.find((clause) => clause.token === ts5.SyntaxKind.ImplementsKeyword);
     return implementClause?.types.map((m) => m.getText()) ?? [];
   }
   /** Gets the tags for a member (protected, readonly, static, etc.) */
@@ -525,7 +470,7 @@ var ClassExtractor = class {
   getMemberDeclarations() {
     const type = this.typeChecker.getTypeAtLocation(this.declaration);
     const members = type.getProperties();
-    const constructor = type.getSymbol()?.members?.get(ts6.InternalSymbolName.Constructor);
+    const constructor = type.getSymbol()?.members?.get(ts5.InternalSymbolName.Constructor);
     const typeOfConstructor = this.typeChecker.getTypeOfSymbol(type.symbol);
     const staticMembers = typeOfConstructor.getProperties();
     const result = [];
@@ -542,9 +487,9 @@ var ClassExtractor = class {
   /** The result only contains properties, method implementations and abstracts */
   filterMethodOverloads(declarations) {
     return declarations.filter((declaration, index) => {
-      if (ts6.isFunctionDeclaration(declaration) || ts6.isMethodDeclaration(declaration) || ts6.isConstructorDeclaration(declaration)) {
+      if (ts5.isFunctionDeclaration(declaration) || ts5.isMethodDeclaration(declaration) || ts5.isConstructorDeclaration(declaration)) {
         const nextDeclaration = declarations[index + 1];
-        const isNextMethodWithSameName = nextDeclaration && (ts6.isMethodDeclaration(nextDeclaration) && nextDeclaration.name.getText() === declaration.name?.getText() || ts6.isConstructorDeclaration(nextDeclaration) && ts6.isConstructorDeclaration(declaration));
+        const isNextMethodWithSameName = nextDeclaration && (ts5.isMethodDeclaration(nextDeclaration) && nextDeclaration.name.getText() === declaration.name?.getText() || ts5.isConstructorDeclaration(nextDeclaration) && ts5.isConstructorDeclaration(declaration));
         return !isNextMethodWithSameName;
       }
       return true;
@@ -563,13 +508,13 @@ var ClassExtractor = class {
   /** Gets the doc tag corresponding to a class member modifier (readonly, protected, etc.). */
   getTagForMemberModifier(mod) {
     switch (mod.kind) {
-      case ts6.SyntaxKind.StaticKeyword:
+      case ts5.SyntaxKind.StaticKeyword:
         return MemberTags.Static;
-      case ts6.SyntaxKind.ReadonlyKeyword:
+      case ts5.SyntaxKind.ReadonlyKeyword:
         return MemberTags.Readonly;
-      case ts6.SyntaxKind.ProtectedKeyword:
+      case ts5.SyntaxKind.ProtectedKeyword:
         return MemberTags.Protected;
-      case ts6.SyntaxKind.AbstractKeyword:
+      case ts5.SyntaxKind.AbstractKeyword:
         return MemberTags.Abstract;
       default:
         return void 0;
@@ -585,39 +530,34 @@ var ClassExtractor = class {
    *  - The member is marked as internal via JSDoc.
    */
   isMemberExcluded(member) {
-    if (ts6.isConstructorDeclaration(member)) {
+    if (ts5.isConstructorDeclaration(member)) {
       return false;
     }
-    return !member.name || !this.isDocumentableMember(member) || !ts6.isCallSignatureDeclaration(member) && member.modifiers?.some((mod) => mod.kind === ts6.SyntaxKind.PrivateKeyword) || member.name.getText() === "prototype" || isAngularPrivateName(member.name.getText()) || isInternal(member);
+    return !member.name || !this.isDocumentableMember(member) || !ts5.isCallSignatureDeclaration(member) && member.modifiers?.some((mod) => mod.kind === ts5.SyntaxKind.PrivateKeyword) || member.name.getText() === "prototype" || isAngularPrivateName(member.name.getText()) || isInternal(member);
   }
   /** Gets whether a class member is a method, property, or accessor. */
   isDocumentableMember(member) {
-    return this.isMethod(member) || this.isProperty(member) || ts6.isAccessor(member) || ts6.isConstructorDeclaration(member) || // Signatures are documentable if they are part of an interface.
-    ts6.isCallSignatureDeclaration(member);
+    return this.isMethod(member) || this.isProperty(member) || ts5.isAccessor(member) || ts5.isConstructorDeclaration(member) || // Signatures are documentable if they are part of an interface.
+    ts5.isCallSignatureDeclaration(member);
   }
   /** Check if the parameter is a constructor parameter with a public modifier */
   isPublicConstructorParameterProperty(node) {
-    if (ts6.isParameterPropertyDeclaration(node, node.parent) && node.modifiers) {
-      return node.modifiers.some((modifier) => modifier.kind === ts6.SyntaxKind.PublicKeyword);
+    if (ts5.isParameterPropertyDeclaration(node, node.parent) && node.modifiers) {
+      return node.modifiers.some((modifier) => modifier.kind === ts5.SyntaxKind.PublicKeyword);
     }
     return false;
   }
   /** Gets whether a member is a property. */
   isProperty(member) {
-    return ts6.isPropertyDeclaration(member) || ts6.isPropertySignature(member) || this.isPublicConstructorParameterProperty(member);
+    return ts5.isPropertyDeclaration(member) || ts5.isPropertySignature(member) || this.isPublicConstructorParameterProperty(member);
   }
   /** Gets whether a member is a method. */
   isMethod(member) {
-    return ts6.isMethodDeclaration(member) || ts6.isMethodSignature(member);
+    return ts5.isMethodDeclaration(member) || ts5.isMethodSignature(member);
   }
   /** Gets whether the given signature declaration is documentable. */
   isDocumentableSignature(signature) {
-    return ts6.isConstructSignatureDeclaration(signature) || ts6.isCallSignatureDeclaration(signature);
-  }
-  /** Gets whether the declaration for this extractor is abstract. */
-  isAbstract() {
-    const modifiers = this.declaration.modifiers ?? [];
-    return modifiers.some((mod) => mod.kind === ts6.SyntaxKind.AbstractKeyword);
+    return ts5.isConstructSignatureDeclaration(signature) || ts5.isCallSignatureDeclaration(signature);
   }
   /**
    * Check wether a member has a private computed property name like [ɵWRITABLE_SIGNAL]
@@ -625,7 +565,48 @@ var ClassExtractor = class {
    * This will prevent exposing private computed properties in the docs.
    */
   hasPrivateComputedProperty(property) {
-    return ts6.isComputedPropertyName(property.name) && property.name.expression.getText().startsWith("\u0275");
+    return ts5.isComputedPropertyName(property.name) && property.name.expression.getText().startsWith("\u0275");
+  }
+};
+
+// packages/compiler-cli/src/ngtsc/docs/src/class_extractor.js
+var ClassExtractor = class extends PropertiesExtractor {
+  constructor(declaration, typeChecker) {
+    super(declaration, typeChecker);
+  }
+  /** Extract docs info specific to classes. */
+  extract() {
+    return {
+      name: this.declaration.name.text,
+      isAbstract: this.isAbstract(),
+      entryType: EntryType.UndecoratedClass,
+      ...super.extract(),
+      description: extractJsDocDescription(this.declaration),
+      jsdocTags: extractJsDocTags(this.declaration),
+      rawComment: extractRawJsDoc(this.declaration),
+      extends: this.extractInheritance(this.declaration),
+      implements: this.extractInterfaceConformance(this.declaration)
+    };
+  }
+  /** Gets whether the declaration for this extractor is abstract. */
+  isAbstract() {
+    const modifiers = this.declaration.modifiers ?? [];
+    return modifiers.some((mod) => mod.kind === ts6.SyntaxKind.AbstractKeyword);
+  }
+  extractInheritance(declaration) {
+    if (!declaration.heritageClauses) {
+      return void 0;
+    }
+    for (const clause of declaration.heritageClauses) {
+      if (clause.token === ts6.SyntaxKind.ExtendsKeyword) {
+        const types = clause.types;
+        if (types.length > 0) {
+          const baseClass = types[0];
+          return baseClass.getText();
+        }
+      }
+    }
+    return void 0;
   }
 };
 var DirectiveExtractor = class extends ClassExtractor {
@@ -724,10 +705,6 @@ function extractClass(classDeclaration, metadataReader, typeChecker) {
   }
   return extractor.extract();
 }
-function extractInterface(declaration, typeChecker) {
-  const extractor = new ClassExtractor(declaration, typeChecker);
-  return extractor.extract();
-}
 function extractPipeSyntax(metadata, classDeclaration) {
   const transformParams = classDeclaration.members.find((member) => {
     return ts6.isMethodDeclaration(member) && member.name && ts6.isIdentifier(member.name) && member.name.getText() === "transform";
@@ -797,7 +774,48 @@ function extractLiteralPropertiesAsEnumMembers(declaration) {
 }
 
 // packages/compiler-cli/src/ngtsc/docs/src/decorator_extractor.js
+import ts9 from "typescript";
+
+// packages/compiler-cli/src/ngtsc/docs/src/interface_extractor.js
 import ts8 from "typescript";
+var InterfaceExtractor = class extends PropertiesExtractor {
+  constructor(declaration, typeChecker) {
+    super(declaration, typeChecker);
+  }
+  /** Extract docs info specific to classes. */
+  extract() {
+    return {
+      name: this.declaration.name.text,
+      entryType: EntryType.Interface,
+      ...super.extract(),
+      description: extractJsDocDescription(this.declaration),
+      jsdocTags: extractJsDocTags(this.declaration),
+      rawComment: extractRawJsDoc(this.declaration),
+      extends: this.extractInheritance(this.declaration),
+      implements: this.extractInterfaceConformance(this.declaration)
+    };
+  }
+  extractInheritance(declaration) {
+    if (!declaration.heritageClauses) {
+      return [];
+    }
+    for (const clause of declaration.heritageClauses) {
+      if (clause.token === ts8.SyntaxKind.ExtendsKeyword) {
+        const types = clause.types;
+        if (types.length > 0) {
+          return types.map((t) => t.getText());
+        }
+      }
+    }
+    return [];
+  }
+};
+function extractInterface(declaration, typeChecker) {
+  const extractor = new InterfaceExtractor(declaration, typeChecker);
+  return extractor.extract();
+}
+
+// packages/compiler-cli/src/ngtsc/docs/src/decorator_extractor.js
 function extractorDecorator(declaration, typeChecker) {
   const documentedNode = getDecoratorJsDocNode(declaration, typeChecker);
   const decoratorType = getDecoratorType(declaration);
@@ -808,7 +826,7 @@ function extractorDecorator(declaration, typeChecker) {
   let signatures = [];
   if (!members) {
     const decoratorInterface = getDecoratorDeclaration(declaration, typeChecker);
-    const callSignatures = decoratorInterface.members.filter(ts8.isCallSignatureDeclaration);
+    const callSignatures = decoratorInterface.members.filter(ts9.isCallSignatureDeclaration);
     signatures = getDecoratorSignatures(callSignatures, typeChecker);
   }
   return {
@@ -826,7 +844,7 @@ function isDecoratorDeclaration(declaration) {
   return !!getDecoratorType(declaration);
 }
 function isDecoratorOptionsInterface(declaration) {
-  return declaration.getSourceFile().statements.some((s) => ts8.isVariableStatement(s) && s.declarationList.declarations.some((d) => isDecoratorDeclaration(d) && d.name.getText() === declaration.name.getText()));
+  return declaration.getSourceFile().statements.some((s) => ts9.isVariableStatement(s) && s.declarationList.declarations.some((d) => isDecoratorDeclaration(d) && d.name.getText() === declaration.name.getText()));
 }
 function getDecoratorType(declaration) {
   const initializer = declaration.initializer?.getFullText() ?? "";
@@ -844,7 +862,7 @@ function getDecoratorDeclaration(declaration, typeChecker) {
   const decoratorType = typeChecker.getTypeAtLocation(decoratorDeclaration);
   const aliasDeclaration = decoratorType.getSymbol().getDeclarations()[0];
   const decoratorInterface = aliasDeclaration;
-  if (!decoratorInterface || !ts8.isInterfaceDeclaration(decoratorInterface)) {
+  if (!decoratorInterface || !ts9.isInterfaceDeclaration(decoratorInterface)) {
     throw new Error(`No decorator interface found for "${decoratorName}".`);
   }
   return decoratorInterface;
@@ -855,12 +873,12 @@ function getDecoratorProperties(declaration, typeChecker) {
   const firstParamType = typeChecker.getTypeAtLocation(decoratorFirstParam);
   let firstParamTypeDecl;
   if (firstParamType.isUnion()) {
-    const firstParamTypeUnion = firstParamType.types.find((t) => (t.flags & ts8.TypeFlags.Undefined) === 0);
+    const firstParamTypeUnion = firstParamType.types.find((t) => (t.flags & ts9.TypeFlags.Undefined) === 0);
     firstParamTypeDecl = firstParamTypeUnion?.getSymbol()?.getDeclarations()[0];
   } else {
     firstParamTypeDecl = firstParamType.getSymbol()?.getDeclarations()[0];
   }
-  if (!firstParamTypeDecl || !ts8.isInterfaceDeclaration(firstParamTypeDecl)) {
+  if (!firstParamTypeDecl || !ts9.isInterfaceDeclaration(firstParamTypeDecl)) {
     return null;
   }
   const interfaceDeclaration = firstParamTypeDecl;
@@ -888,7 +906,7 @@ function getDecoratorInterface(declaration, typeChecker) {
   const symbol = typeChecker.getSymbolAtLocation(declaration.name);
   const decoratorType = typeChecker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
   const decoratorInterface = decoratorType.getSymbol()?.getDeclarations()[0];
-  if (!decoratorInterface || !ts8.isInterfaceDeclaration(decoratorInterface)) {
+  if (!decoratorInterface || !ts9.isInterfaceDeclaration(decoratorInterface)) {
     throw new Error(`No decorator interface found for "${name}".`);
   }
   return decoratorInterface;
@@ -897,22 +915,22 @@ function getDecoratorJsDocNode(declaration, typeChecker) {
   const name = declaration.name.getText();
   const decoratorInterface = getDecoratorInterface(declaration, typeChecker);
   const callSignature = decoratorInterface.members.filter((node) => {
-    return ts8.isCallSignatureDeclaration(node) && extractRawJsDoc(node);
+    return ts9.isCallSignatureDeclaration(node) && extractRawJsDoc(node);
   }).at(-1);
-  if (!callSignature || !ts8.isCallSignatureDeclaration(callSignature)) {
+  if (!callSignature || !ts9.isCallSignatureDeclaration(callSignature)) {
     throw new Error(`No call signature with JsDoc on "${name}Decorator"`);
   }
   return callSignature;
 }
 function getParamTypeString(paramNode, typeChecker) {
   const type = typeChecker.getTypeAtLocation(paramNode);
-  const printer = ts8.createPrinter({ removeComments: true });
+  const printer = ts9.createPrinter({ removeComments: true });
   const sourceFile = paramNode.getSourceFile();
   const replace = [];
   if (type.isUnion()) {
     for (const subType of type.types) {
       const decl = subType.getSymbol()?.getDeclarations()?.[0];
-      if (decl && ts8.isInterfaceDeclaration(decl) && decl.name.text !== "Function") {
+      if (decl && ts9.isInterfaceDeclaration(decl) && decl.name.text !== "Function") {
         replace.push({
           initial: subType.symbol.name,
           replacedWith: expandType(decl, sourceFile, printer)
@@ -920,19 +938,19 @@ function getParamTypeString(paramNode, typeChecker) {
       }
     }
   }
-  let result = printer.printNode(ts8.EmitHint.Unspecified, paramNode, sourceFile).replace(new RegExp(`${paramNode.name.getText()}\\??: `), "").replaceAll(/\s+/g, " ");
+  let result = printer.printNode(ts9.EmitHint.Unspecified, paramNode, sourceFile).replace(new RegExp(`${paramNode.name.getText()}\\??: `), "").replaceAll(/\s+/g, " ");
   for (const { initial, replacedWith } of replace) {
     result = result.replace(initial, replacedWith);
   }
   return result;
 }
 function expandType(decl, sourceFile, printer) {
-  const props = decl.members.map((member) => printer.printNode(ts8.EmitHint.Unspecified, member, sourceFile)).join(" ").replaceAll(/\s+/g, " ");
+  const props = decl.members.map((member) => printer.printNode(ts9.EmitHint.Unspecified, member, sourceFile)).join(" ").replaceAll(/\s+/g, " ");
   return `{${props}}`;
 }
 
 // packages/compiler-cli/src/ngtsc/docs/src/enum_extractor.js
-import ts9 from "typescript";
+import ts10 from "typescript";
 function extractEnum(declaration, typeChecker) {
   return {
     name: declaration.name.getText(),
@@ -956,36 +974,36 @@ function extractEnumMembers(declaration, checker) {
 }
 function getEnumMemberValue(memberNode) {
   const literal = memberNode.getChildren().find((n) => {
-    return ts9.isNumericLiteral(n) || ts9.isStringLiteral(n) || ts9.isPrefixUnaryExpression(n) && n.operator === ts9.SyntaxKind.MinusToken && ts9.isNumericLiteral(n.operand);
+    return ts10.isNumericLiteral(n) || ts10.isStringLiteral(n) || ts10.isPrefixUnaryExpression(n) && n.operator === ts10.SyntaxKind.MinusToken && ts10.isNumericLiteral(n.operand);
   });
   return literal?.getText() ?? "";
 }
 
 // packages/compiler-cli/src/ngtsc/docs/src/initializer_api_function_extractor.js
-import ts10 from "typescript";
+import ts11 from "typescript";
 var initializerApiTag = "initializerApiFunction";
 function isInitializerApiFunction(node, typeChecker) {
-  if (ts10.isFunctionDeclaration(node) && node.name !== void 0 && node.body === void 0) {
+  if (ts11.isFunctionDeclaration(node) && node.name !== void 0 && node.body === void 0) {
     const implementation = findImplementationOfFunction(node, typeChecker);
     if (implementation !== void 0) {
       node = implementation;
     }
   }
-  if (!ts10.isFunctionDeclaration(node) && !ts10.isVariableDeclaration(node)) {
+  if (!ts11.isFunctionDeclaration(node) && !ts11.isVariableDeclaration(node)) {
     return false;
   }
-  let tagContainer = ts10.isFunctionDeclaration(node) ? node : getContainerVariableStatement(node);
+  let tagContainer = ts11.isFunctionDeclaration(node) ? node : getContainerVariableStatement(node);
   if (tagContainer === null) {
     return false;
   }
-  const tags = ts10.getJSDocTags(tagContainer);
+  const tags = ts11.getJSDocTags(tagContainer);
   return tags.some((t) => t.tagName.text === initializerApiTag);
 }
 function extractInitializerApiFunction(node, typeChecker) {
-  if (node.name === void 0 || !ts10.isIdentifier(node.name)) {
+  if (node.name === void 0 || !ts11.isIdentifier(node.name)) {
     throw new Error(`Initializer API: Expected literal variable name.`);
   }
-  const container = ts10.isFunctionDeclaration(node) ? node : getContainerVariableStatement(node);
+  const container = ts11.isFunctionDeclaration(node) ? node : getContainerVariableStatement(node);
   if (container === null) {
     throw new Error("Initializer API: Could not find container AST node of variable.");
   }
@@ -996,7 +1014,7 @@ function extractInitializerApiFunction(node, typeChecker) {
   for (const property of type.getProperties()) {
     const subName = property.getName();
     const subDecl = property.getDeclarations()?.[0];
-    if (subDecl === void 0 || !ts10.isPropertySignature(subDecl)) {
+    if (subDecl === void 0 || !ts11.isPropertySignature(subDecl)) {
       throw new Error(`Initializer API: Could not resolve declaration of sub-property: ${name}.${subName}`);
     }
     const subType = typeChecker.getTypeAtLocation(subDecl);
@@ -1005,7 +1023,7 @@ function extractInitializerApiFunction(node, typeChecker) {
   let jsdocTags;
   let description;
   let rawComment;
-  if (ts10.isFunctionDeclaration(node)) {
+  if (ts11.isFunctionDeclaration(node)) {
     const implementation = findImplementationOfFunction(node, typeChecker);
     if (implementation === void 0) {
       throw new Error(`Initializer API: Could not find implementation of function: ${name}`);
@@ -1053,10 +1071,10 @@ function extractInitializerApiFunction(node, typeChecker) {
   };
 }
 function getContainerVariableStatement(node) {
-  if (!ts10.isVariableDeclarationList(node.parent)) {
+  if (!ts11.isVariableDeclarationList(node.parent)) {
     return null;
   }
-  if (!ts10.isVariableStatement(node.parent.parent)) {
+  if (!ts11.isVariableStatement(node.parent.parent)) {
     return null;
   }
   return node.parent.parent;
@@ -1084,15 +1102,15 @@ function extractTypeAlias(declaration) {
 }
 
 // packages/compiler-cli/src/ngtsc/docs/src/import_extractor.js
-import ts11 from "typescript";
+import ts12 from "typescript";
 function getImportedSymbols(sourceFile) {
   const importSpecifiers = /* @__PURE__ */ new Map();
   function visit(node) {
-    if (ts11.isImportDeclaration(node)) {
+    if (ts12.isImportDeclaration(node)) {
       let moduleSpecifier = node.moduleSpecifier.getText(sourceFile).replace(/['"]/g, "");
       if (moduleSpecifier.startsWith("@angular/")) {
         const namedBindings = node.importClause?.namedBindings;
-        if (namedBindings && ts11.isNamedImports(namedBindings)) {
+        if (namedBindings && ts12.isNamedImports(namedBindings)) {
           namedBindings.elements.forEach((importSpecifier) => {
             const importName = importSpecifier.name.text;
             const importAlias = importSpecifier.propertyName ? importSpecifier.propertyName.text : void 0;
@@ -1101,7 +1119,7 @@ function getImportedSymbols(sourceFile) {
         }
       }
     }
-    ts11.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   }
   visit(sourceFile);
   return importSpecifiers;
@@ -1145,8 +1163,8 @@ var DocsExtractor = class {
         entry.source = {
           filePath: getRelativeFilePath(realSourceFile, rootDir),
           // Start & End are off by 1
-          startLine: ts12.getLineAndCharacterOfPosition(realSourceFile, node.getStart()).line + 1,
-          endLine: ts12.getLineAndCharacterOfPosition(realSourceFile, node.getEnd()).line + 1
+          startLine: ts13.getLineAndCharacterOfPosition(realSourceFile, node.getStart()).line + 1,
+          endLine: ts13.getLineAndCharacterOfPosition(realSourceFile, node.getEnd()).line + 1
         };
         entries.push({ ...entry, name: exportName });
       }
@@ -1161,20 +1179,20 @@ var DocsExtractor = class {
     if (isInitializerApiFunction(node, this.typeChecker)) {
       return extractInitializerApiFunction(node, this.typeChecker);
     }
-    if (ts12.isInterfaceDeclaration(node) && !isIgnoredInterface(node)) {
+    if (ts13.isInterfaceDeclaration(node) && !isIgnoredInterface(node)) {
       return extractInterface(node, this.typeChecker);
     }
-    if (ts12.isFunctionDeclaration(node)) {
+    if (ts13.isFunctionDeclaration(node)) {
       const functionExtractor = new FunctionExtractor(node.name.getText(), node, this.typeChecker);
       return functionExtractor.extract();
     }
-    if (ts12.isVariableDeclaration(node) && !isSyntheticAngularConstant(node)) {
+    if (ts13.isVariableDeclaration(node) && !isSyntheticAngularConstant(node)) {
       return isDecoratorDeclaration(node) ? extractorDecorator(node, this.typeChecker) : extractConstant(node, this.typeChecker);
     }
-    if (ts12.isTypeAliasDeclaration(node)) {
+    if (ts13.isTypeAliasDeclaration(node)) {
       return extractTypeAlias(node);
     }
-    if (ts12.isEnumDeclaration(node)) {
+    if (ts13.isEnumDeclaration(node)) {
       return extractEnum(node, this.typeChecker);
     }
     return null;
@@ -1203,111 +1221,13 @@ function getRelativeFilePath(sourceFile, rootDir) {
   return relativePath;
 }
 
-// packages/compiler-cli/src/ngtsc/program.js
-import { HtmlParser, MessageBundle } from "@angular/compiler";
-import ts28 from "typescript";
-
-// packages/compiler-cli/src/transformers/i18n.js
-import { Xliff, Xliff2, Xmb } from "@angular/compiler";
-import * as path from "path";
-function i18nGetExtension(formatName) {
-  const format = formatName.toLowerCase();
-  switch (format) {
-    case "xmb":
-      return "xmb";
-    case "xlf":
-    case "xlif":
-    case "xliff":
-    case "xlf2":
-    case "xliff2":
-      return "xlf";
-  }
-  throw new Error(`Unsupported format "${formatName}"`);
-}
-function i18nExtract(formatName, outFile, host, options, bundle, pathResolve = path.resolve) {
-  formatName = formatName || "xlf";
-  const ext = i18nGetExtension(formatName);
-  const content = i18nSerialize(bundle, formatName, options);
-  const dstFile = outFile || `messages.${ext}`;
-  const dstPath = pathResolve(options.outDir || options.basePath, dstFile);
-  host.writeFile(dstPath, content, false, void 0, []);
-  return [dstPath];
-}
-function i18nSerialize(bundle, formatName, options) {
-  const format = formatName.toLowerCase();
-  let serializer;
-  switch (format) {
-    case "xmb":
-      serializer = new Xmb();
-      break;
-    case "xliff2":
-    case "xlf2":
-      serializer = new Xliff2();
-      break;
-    case "xlf":
-    case "xliff":
-    default:
-      serializer = new Xliff();
-  }
-  return bundle.write(serializer, getPathNormalizer(options.basePath));
-}
-function getPathNormalizer(basePath) {
-  return (sourcePath) => {
-    sourcePath = basePath ? path.relative(basePath, sourcePath) : sourcePath;
-    return sourcePath.split(path.sep).join("/");
-  };
-}
-
-// packages/compiler-cli/src/typescript_support.js
-import ts13 from "typescript";
-
-// packages/compiler-cli/src/version_helpers.js
-function toNumbers(value) {
-  const suffixIndex = value.lastIndexOf("-");
-  return value.slice(0, suffixIndex === -1 ? value.length : suffixIndex).split(".").map((segment) => {
-    const parsed = parseInt(segment, 10);
-    if (isNaN(parsed)) {
-      throw Error(`Unable to parse version string ${value}.`);
-    }
-    return parsed;
-  });
-}
-function compareNumbers(a, b) {
-  const max = Math.max(a.length, b.length);
-  const min = Math.min(a.length, b.length);
-  for (let i = 0; i < min; i++) {
-    if (a[i] > b[i])
-      return 1;
-    if (a[i] < b[i])
-      return -1;
-  }
-  if (min !== max) {
-    const longestArray = a.length === max ? a : b;
-    const comparisonResult = a.length === max ? 1 : -1;
-    for (let i = min; i < max; i++) {
-      if (longestArray[i] > 0) {
-        return comparisonResult;
-      }
-    }
-  }
-  return 0;
-}
-function compareVersions(v1, v2) {
-  return compareNumbers(toNumbers(v1), toNumbers(v2));
-}
-
-// packages/compiler-cli/src/typescript_support.js
-var MIN_TS_VERSION = "5.9.0";
-var MAX_TS_VERSION = "6.0.0";
-var tsVersion = ts13.version;
-function checkVersion(version, minVersion, maxVersion) {
-  if (compareVersions(version, minVersion) < 0 || compareVersions(version, maxVersion) >= 0) {
-    throw new Error(`The Angular Compiler requires TypeScript >=${minVersion} and <${maxVersion} but ${version} was found instead.`);
-  }
-}
-function verifySupportedTypeScriptVersion() {
-  checkVersion(tsVersion, MIN_TS_VERSION, MAX_TS_VERSION);
-}
+// packages/compiler-cli/src/ngtsc/core/api/src/public_options.js
+var DiagnosticCategoryLabel;
+(function(DiagnosticCategoryLabel2) {
+  DiagnosticCategoryLabel2["Warning"] = "warning";
+  DiagnosticCategoryLabel2["Error"] = "error";
+  DiagnosticCategoryLabel2["Suppress"] = "suppress";
+})(DiagnosticCategoryLabel || (DiagnosticCategoryLabel = {}));
 
 // packages/compiler-cli/src/ngtsc/core/src/compiler.js
 import ts26 from "typescript";
@@ -3077,7 +2997,9 @@ var KNOWN_CONTROL_FLOW_DIRECTIVES2 = /* @__PURE__ */ new Set([
   "ngForOf",
   "ngForTrackBy",
   "ngSwitchCase",
-  "ngSwitchDefault"
+  "ngSwitchDefault",
+  "ngIfThen",
+  "ngIfElse"
 ]);
 var MissingStructuralDirectiveCheck = class extends TemplateCheckWithVisitor {
   code = ErrorCode.MISSING_STRUCTURAL_DIRECTIVE;
@@ -3095,9 +3017,9 @@ var MissingStructuralDirectiveCheck = class extends TemplateCheckWithVisitor {
     if (!customStructuralDirective)
       return [];
     const symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
-    if (symbol?.directives.length) {
+    const hasStructuralDirective = symbol?.directives.some((dir) => dir.selector?.includes(`[${customStructuralDirective.name}]`));
+    if (hasStructuralDirective)
       return [];
-    }
     const sourceSpan = customStructuralDirective.keySpan || customStructuralDirective.sourceSpan;
     const errorMessage = `A structural directive \`${customStructuralDirective.name}\` was used in the template without a corresponding import in the component. Make sure that the directive is included in the \`@Component.imports\` array of this component.`;
     return [ctx.makeTemplateDiagnostic(sourceSpan, errorMessage)];
@@ -3544,16 +3466,6 @@ var factory16 = {
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker.js
 import ts21 from "typescript";
-
-// packages/compiler-cli/src/ngtsc/core/api/src/public_options.js
-var DiagnosticCategoryLabel;
-(function(DiagnosticCategoryLabel2) {
-  DiagnosticCategoryLabel2["Warning"] = "warning";
-  DiagnosticCategoryLabel2["Error"] = "error";
-  DiagnosticCategoryLabel2["Suppress"] = "suppress";
-})(DiagnosticCategoryLabel || (DiagnosticCategoryLabel = {}));
-
-// packages/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker.js
 var ExtendedTemplateCheckerImpl = class {
   partialCtx;
   templateChecks;
@@ -5250,491 +5162,21 @@ var NgCompilerHost = class _NgCompilerHost extends DelegatingCompilerHost {
   }
 };
 
-// packages/compiler-cli/src/ngtsc/program.js
-var NgtscProgram = class {
-  options;
-  compiler;
-  /**
-   * The primary TypeScript program, which is used for analysis and emit.
-   */
-  tsProgram;
-  host;
-  incrementalStrategy;
-  constructor(rootNames, options, delegateHost, oldProgram) {
-    this.options = options;
-    const perfRecorder = ActivePerfRecorder.zeroedToNow();
-    perfRecorder.phase(PerfPhase.Setup);
-    if (!options.disableTypeScriptVersionCheck) {
-      verifySupportedTypeScriptVersion();
-    }
-    if (options.compilationMode === "experimental-local") {
-      options.noEmitOnError = false;
-    }
-    const reuseProgram = oldProgram?.compiler.getCurrentProgram();
-    this.host = NgCompilerHost.wrap(delegateHost, rootNames, options, reuseProgram ?? null);
-    if (reuseProgram !== void 0) {
-      retagAllTsFiles(reuseProgram);
-    }
-    this.tsProgram = perfRecorder.inPhase(PerfPhase.TypeScriptProgramCreate, () => ts28.createProgram(this.host.inputFiles, options, this.host, reuseProgram));
-    perfRecorder.phase(PerfPhase.Unaccounted);
-    perfRecorder.memory(PerfCheckpoint.TypeScriptProgramCreate);
-    this.host.postProgramCreationCleanup();
-    const programDriver = new TsCreateProgramDriver(this.tsProgram, this.host, this.options, this.host.shimExtensionPrefixes);
-    this.incrementalStrategy = oldProgram !== void 0 ? oldProgram.incrementalStrategy.toNextBuildStrategy() : new TrackedIncrementalBuildStrategy();
-    const modifiedResourceFiles = /* @__PURE__ */ new Set();
-    if (this.host.getModifiedResourceFiles !== void 0) {
-      const strings = this.host.getModifiedResourceFiles();
-      if (strings !== void 0) {
-        for (const fileString of strings) {
-          modifiedResourceFiles.add(absoluteFrom(fileString));
-        }
-      }
-    }
-    let ticket;
-    if (oldProgram === void 0) {
-      ticket = freshCompilationTicket(
-        this.tsProgram,
-        options,
-        this.incrementalStrategy,
-        programDriver,
-        perfRecorder,
-        /* enableTemplateTypeChecker */
-        false,
-        /* usePoisonedData */
-        false
-      );
-    } else {
-      ticket = incrementalFromCompilerTicket(oldProgram.compiler, this.tsProgram, this.incrementalStrategy, programDriver, modifiedResourceFiles, perfRecorder);
-    }
-    this.compiler = NgCompiler.fromTicket(ticket, this.host);
-  }
-  getTsProgram() {
-    return this.tsProgram;
-  }
-  getReuseTsProgram() {
-    return this.compiler.getCurrentProgram();
-  }
-  getTsOptionDiagnostics(cancellationToken) {
-    return this.compiler.perfRecorder.inPhase(PerfPhase.TypeScriptDiagnostics, () => this.tsProgram.getOptionsDiagnostics(cancellationToken));
-  }
-  getTsSyntacticDiagnostics(sourceFile, cancellationToken) {
-    return this.compiler.perfRecorder.inPhase(PerfPhase.TypeScriptDiagnostics, () => {
-      const ignoredFiles = this.compiler.ignoreForDiagnostics;
-      let res;
-      if (sourceFile !== void 0) {
-        if (ignoredFiles.has(sourceFile)) {
-          return [];
-        }
-        res = this.tsProgram.getSyntacticDiagnostics(sourceFile, cancellationToken);
-      } else {
-        const diagnostics = [];
-        for (const sf of this.tsProgram.getSourceFiles()) {
-          if (!ignoredFiles.has(sf)) {
-            diagnostics.push(...this.tsProgram.getSyntacticDiagnostics(sf, cancellationToken));
-          }
-        }
-        res = diagnostics;
-      }
-      return res;
-    });
-  }
-  getTsSemanticDiagnostics(sourceFile, cancellationToken) {
-    if (this.options.compilationMode === "experimental-local") {
-      return [];
-    }
-    return this.compiler.perfRecorder.inPhase(PerfPhase.TypeScriptDiagnostics, () => {
-      const ignoredFiles = this.compiler.ignoreForDiagnostics;
-      let res;
-      if (sourceFile !== void 0) {
-        if (ignoredFiles.has(sourceFile)) {
-          return [];
-        }
-        res = this.tsProgram.getSemanticDiagnostics(sourceFile, cancellationToken);
-      } else {
-        const diagnostics = [];
-        for (const sf of this.tsProgram.getSourceFiles()) {
-          if (!ignoredFiles.has(sf)) {
-            diagnostics.push(...this.tsProgram.getSemanticDiagnostics(sf, cancellationToken));
-          }
-        }
-        res = diagnostics;
-      }
-      return res;
-    });
-  }
-  getNgOptionDiagnostics(cancellationToken) {
-    return this.compiler.getOptionDiagnostics();
-  }
-  getNgStructuralDiagnostics(cancellationToken) {
-    return [];
-  }
-  getNgSemanticDiagnostics(fileName, cancellationToken) {
-    let sf = void 0;
-    if (fileName !== void 0) {
-      sf = this.tsProgram.getSourceFile(fileName);
-      if (sf === void 0) {
-        return [];
-      }
-    }
-    if (sf === void 0) {
-      return this.compiler.getDiagnostics();
-    } else {
-      return this.compiler.getDiagnosticsForFile(sf, OptimizeFor.WholeProgram);
-    }
-  }
-  /**
-   * Ensure that the `NgCompiler` has properly analyzed the program, and allow for the asynchronous
-   * loading of any resources during the process.
-   *
-   * This is used by the Angular CLI to allow for spawning (async) child compilations for things
-   * like SASS files used in `styleUrls`.
-   */
-  loadNgStructureAsync() {
-    return this.compiler.analyzeAsync();
-  }
-  listLazyRoutes(entryRoute) {
-    return [];
-  }
-  emitXi18n() {
-    const ctx = new MessageBundle(new HtmlParser(), [], {}, this.options.i18nOutLocale ?? null, this.options.i18nPreserveWhitespaceForLegacyExtraction);
-    this.compiler.xi18n(ctx);
-    i18nExtract(this.options.i18nOutFormat ?? null, this.options.i18nOutFile ?? null, this.host, this.options, ctx, resolve);
-  }
-  emit(opts) {
-    if (opts !== void 0 && opts.emitFlags !== void 0 && opts.emitFlags & EmitFlags.I18nBundle) {
-      this.emitXi18n();
-      if (!(opts.emitFlags & EmitFlags.JS)) {
-        return {
-          diagnostics: [],
-          emitSkipped: true,
-          emittedFiles: []
-        };
-      }
-    }
-    const forceEmit = opts?.forceEmit ?? false;
-    this.compiler.perfRecorder.memory(PerfCheckpoint.PreEmit);
-    const res = this.compiler.perfRecorder.inPhase(PerfPhase.TypeScriptEmit, () => {
-      const { transformers } = this.compiler.prepareEmit();
-      const ignoreFiles = this.compiler.ignoreForEmit;
-      const emitCallback = opts?.emitCallback ?? defaultEmitCallback;
-      const writeFile = (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
-        if (sourceFiles !== void 0) {
-          for (const writtenSf of sourceFiles) {
-            if (writtenSf.isDeclarationFile) {
-              continue;
-            }
-            this.compiler.incrementalCompilation.recordSuccessfulEmit(writtenSf);
-          }
-        }
-        this.host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles);
-      };
-      const customTransforms = opts && opts.customTransformers;
-      const beforeTransforms = transformers.before || [];
-      const afterDeclarationsTransforms = transformers.afterDeclarations;
-      if (customTransforms !== void 0 && customTransforms.beforeTs !== void 0) {
-        beforeTransforms.push(...customTransforms.beforeTs);
-      }
-      const emitResults = [];
-      for (const targetSourceFile of this.tsProgram.getSourceFiles()) {
-        if (targetSourceFile.isDeclarationFile || ignoreFiles.has(targetSourceFile)) {
-          continue;
-        }
-        if (!forceEmit && this.compiler.incrementalCompilation.safeToSkipEmit(targetSourceFile)) {
-          this.compiler.perfRecorder.eventCount(PerfEvent.EmitSkipSourceFile);
-          continue;
-        }
-        this.compiler.perfRecorder.eventCount(PerfEvent.EmitSourceFile);
-        emitResults.push(emitCallback({
-          targetSourceFile,
-          program: this.tsProgram,
-          host: this.host,
-          options: this.options,
-          emitOnlyDtsFiles: false,
-          writeFile,
-          customTransformers: {
-            before: beforeTransforms,
-            after: customTransforms && customTransforms.afterTs,
-            afterDeclarations: afterDeclarationsTransforms
-          }
-        }));
-      }
-      this.compiler.perfRecorder.memory(PerfCheckpoint.Emit);
-      return (opts && opts.mergeEmitResultsCallback || mergeEmitResults)(emitResults);
-    });
-    if (this.options.tracePerformance !== void 0) {
-      const perf = this.compiler.perfRecorder.finalize();
-      getFileSystem().writeFile(getFileSystem().resolve(this.options.tracePerformance), JSON.stringify(perf, null, 2));
-    }
-    return res;
-  }
-  getIndexedComponents() {
-    return this.compiler.getIndexedComponents();
-  }
-  /**
-   * Gets information for the current program that may be used to generate API
-   * reference documentation. This includes Angular-specific information, such
-   * as component inputs and outputs.
-   *
-   * @param entryPoint Path to the entry point for the package for which API
-   *     docs should be extracted.
-   */
-  getApiDocumentation(entryPoint, privateModules) {
-    return this.compiler.getApiDocumentation(entryPoint, privateModules);
-  }
-  getEmittedSourceFiles() {
-    throw new Error("Method not implemented.");
-  }
-};
-var defaultEmitCallback = ({ program, targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers }) => program.emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
-function mergeEmitResults(emitResults) {
-  const diagnostics = [];
-  let emitSkipped = false;
-  const emittedFiles = [];
-  for (const er of emitResults) {
-    diagnostics.push(...er.diagnostics);
-    emitSkipped = emitSkipped || er.emitSkipped;
-    emittedFiles.push(...er.emittedFiles || []);
-  }
-  return { diagnostics, emitSkipped, emittedFiles };
-}
-
-// packages/compiler-cli/src/transformers/program.js
-function createProgram({ rootNames, options, host, oldProgram }) {
-  return new NgtscProgram(rootNames, options, host, oldProgram);
-}
-
-// packages/compiler-cli/src/perform_compile.js
-import ts30 from "typescript";
-
-// packages/compiler-cli/src/transformers/util.js
-import ts29 from "typescript";
-function createMessageDiagnostic(messageText) {
-  return {
-    file: void 0,
-    start: void 0,
-    length: void 0,
-    category: ts29.DiagnosticCategory.Message,
-    messageText,
-    code: DEFAULT_ERROR_CODE,
-    source: SOURCE
-  };
-}
-
-// packages/compiler-cli/src/perform_compile.js
-var defaultFormatHost = {
-  getCurrentDirectory: () => ts30.sys.getCurrentDirectory(),
-  getCanonicalFileName: (fileName) => fileName,
-  getNewLine: () => ts30.sys.newLine
-};
-function formatDiagnostics(diags, host = defaultFormatHost) {
-  if (diags && diags.length) {
-    return diags.map((diagnostic) => replaceTsWithNgInErrors(ts30.formatDiagnosticsWithColorAndContext([diagnostic], host))).join("");
-  } else {
-    return "";
-  }
-}
-function calcProjectFileAndBasePath(project, host = getFileSystem()) {
-  const absProject = host.resolve(project);
-  const projectIsDir = host.lstat(absProject).isDirectory();
-  const projectFile = projectIsDir ? host.join(absProject, "tsconfig.json") : absProject;
-  const projectDir = projectIsDir ? absProject : host.dirname(absProject);
-  const basePath = host.resolve(projectDir);
-  return { projectFile, basePath };
-}
-function readConfiguration(project, existingOptions, host = getFileSystem()) {
-  try {
-    const fs = getFileSystem();
-    const readConfigFile = (configFile) => ts30.readConfigFile(configFile, (file) => host.readFile(host.resolve(file)));
-    const readAngularCompilerOptions = (configFile, parentOptions = {}) => {
-      const { config: config2, error: error2 } = readConfigFile(configFile);
-      if (error2) {
-        return parentOptions;
-      }
-      const angularCompilerOptions = config2.angularCompilerOptions ?? config2.bazelOptions?.angularCompilerOptions;
-      let existingNgCompilerOptions = { ...angularCompilerOptions, ...parentOptions };
-      if (!config2.extends) {
-        return existingNgCompilerOptions;
-      }
-      const extendsPaths = typeof config2.extends === "string" ? [config2.extends] : config2.extends;
-      return [...extendsPaths].reverse().reduce((prevOptions, extendsPath) => {
-        const extendedConfigPath = getExtendedConfigPath(configFile, extendsPath, host, fs);
-        return extendedConfigPath === null ? prevOptions : readAngularCompilerOptions(extendedConfigPath, prevOptions);
-      }, existingNgCompilerOptions);
-    };
-    const { projectFile, basePath } = calcProjectFileAndBasePath(project, host);
-    const configFileName = host.resolve(host.pwd(), projectFile);
-    const { config, error } = readConfigFile(projectFile);
-    if (error) {
-      return {
-        project,
-        errors: [error],
-        rootNames: [],
-        options: {},
-        emitFlags: EmitFlags.Default
-      };
-    }
-    const existingCompilerOptions = {
-      genDir: basePath,
-      basePath,
-      ...readAngularCompilerOptions(configFileName),
-      ...existingOptions
-    };
-    const parseConfigHost = createParseConfigHost(host, fs);
-    const { options, errors, fileNames: rootNames, projectReferences } = ts30.parseJsonConfigFileContent(config, parseConfigHost, basePath, existingCompilerOptions, configFileName);
-    let emitFlags = EmitFlags.Default;
-    if (!(options["skipMetadataEmit"] || options["flatModuleOutFile"])) {
-      emitFlags |= EmitFlags.Metadata;
-    }
-    if (options["skipTemplateCodegen"]) {
-      emitFlags = emitFlags & ~EmitFlags.Codegen;
-    }
-    return { project: projectFile, rootNames, projectReferences, options, errors, emitFlags };
-  } catch (e) {
-    const errors = [
-      {
-        category: ts30.DiagnosticCategory.Error,
-        messageText: e.stack ?? e.message,
-        file: void 0,
-        start: void 0,
-        length: void 0,
-        source: "angular",
-        code: UNKNOWN_ERROR_CODE
-      }
-    ];
-    return { project: "", errors, rootNames: [], options: {}, emitFlags: EmitFlags.Default };
-  }
-}
-function createParseConfigHost(host, fs = getFileSystem()) {
-  return {
-    fileExists: host.exists.bind(host),
-    readDirectory: createFileSystemTsReadDirectoryFn(fs),
-    readFile: host.readFile.bind(host),
-    useCaseSensitiveFileNames: fs.isCaseSensitive()
-  };
-}
-function getExtendedConfigPath(configFile, extendsValue, host, fs) {
-  const result = getExtendedConfigPathWorker(configFile, extendsValue, host, fs);
-  if (result !== null) {
-    return result;
-  }
-  return getExtendedConfigPathWorker(configFile, `${extendsValue}.json`, host, fs);
-}
-function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
-  if (extendsValue.startsWith(".") || fs.isRooted(extendsValue)) {
-    const extendedConfigPath = host.resolve(host.dirname(configFile), extendsValue);
-    if (host.exists(extendedConfigPath)) {
-      return extendedConfigPath;
-    }
-  } else {
-    const parseConfigHost = createParseConfigHost(host, fs);
-    const { resolvedModule } = ts30.nodeModuleNameResolver(extendsValue, configFile, { moduleResolution: ts30.ModuleResolutionKind.Node10, resolveJsonModule: true }, parseConfigHost);
-    if (resolvedModule) {
-      return absoluteFrom(resolvedModule.resolvedFileName);
-    }
-  }
-  return null;
-}
-function exitCodeFromResult(diags) {
-  if (!diags)
-    return 0;
-  if (diags.every((diag) => diag.category !== ts30.DiagnosticCategory.Error)) {
-    return 0;
-  }
-  return diags.some((d) => d.source === "angular" && d.code === UNKNOWN_ERROR_CODE) ? 2 : 1;
-}
-function performCompilation({ rootNames, options, host, oldProgram, emitCallback, mergeEmitResultsCallback, gatherDiagnostics = defaultGatherDiagnostics, customTransformers, emitFlags = EmitFlags.Default, forceEmit = false, modifiedResourceFiles = null }) {
-  let program;
-  let emitResult;
-  let allDiagnostics = [];
-  try {
-    if (!host) {
-      host = createCompilerHost({ options });
-    }
-    if (modifiedResourceFiles) {
-      host.getModifiedResourceFiles = () => modifiedResourceFiles;
-    }
-    program = createProgram({ rootNames, host, options, oldProgram });
-    const beforeDiags = Date.now();
-    allDiagnostics.push(...gatherDiagnostics(program));
-    if (options.diagnostics) {
-      const afterDiags = Date.now();
-      allDiagnostics.push(createMessageDiagnostic(`Time for diagnostics: ${afterDiags - beforeDiags}ms.`));
-    }
-    if (!hasErrors(allDiagnostics)) {
-      emitResult = program.emit({
-        emitCallback,
-        mergeEmitResultsCallback,
-        customTransformers,
-        emitFlags,
-        forceEmit
-      });
-      allDiagnostics.push(...emitResult.diagnostics);
-      return { diagnostics: allDiagnostics, program, emitResult };
-    }
-    return { diagnostics: allDiagnostics, program };
-  } catch (e) {
-    program = void 0;
-    allDiagnostics.push({
-      category: ts30.DiagnosticCategory.Error,
-      messageText: e.stack ?? e.message,
-      code: UNKNOWN_ERROR_CODE,
-      file: void 0,
-      start: void 0,
-      length: void 0
-    });
-    return { diagnostics: allDiagnostics, program };
-  }
-}
-function defaultGatherDiagnostics(program) {
-  const allDiagnostics = [];
-  function checkDiagnostics(diags) {
-    if (diags) {
-      allDiagnostics.push(...diags);
-      return !hasErrors(diags);
-    }
-    return true;
-  }
-  let checkOtherDiagnostics = true;
-  checkOtherDiagnostics = checkOtherDiagnostics && checkDiagnostics([...program.getTsOptionDiagnostics(), ...program.getNgOptionDiagnostics()]);
-  checkOtherDiagnostics = checkOtherDiagnostics && checkDiagnostics(program.getTsSyntacticDiagnostics());
-  checkOtherDiagnostics = checkOtherDiagnostics && checkDiagnostics([
-    ...program.getTsSemanticDiagnostics(),
-    ...program.getNgStructuralDiagnostics()
-  ]);
-  checkOtherDiagnostics = checkOtherDiagnostics && checkDiagnostics(program.getNgSemanticDiagnostics());
-  return allDiagnostics;
-}
-function hasErrors(diags) {
-  return diags.some((d) => d.category === ts30.DiagnosticCategory.Error);
-}
-
 export {
-  DEFAULT_ERROR_CODE,
-  UNKNOWN_ERROR_CODE,
-  SOURCE,
-  isTsDiagnostic,
-  EmitFlags,
-  createCompilerHost,
   EntryType,
   MemberType,
   DecoratorType,
   MemberTags,
   isDocEntryWithSourceInfo,
   DocsExtractor,
+  TrackedIncrementalBuildStrategy,
   PatchedProgramIncrementalBuildStrategy,
+  DiagnosticCategoryLabel,
   freshCompilationTicket,
+  incrementalFromCompilerTicket,
   incrementalFromStateTicket,
   NgCompiler,
-  NgCompilerHost,
-  NgtscProgram,
-  createProgram,
-  createMessageDiagnostic,
-  formatDiagnostics,
-  calcProjectFileAndBasePath,
-  readConfiguration,
-  exitCodeFromResult,
-  performCompilation,
-  defaultGatherDiagnostics
+  NgCompilerHost
 };
 /**
  * @license