@angular/compiler-cli 17.3.1 → 17.3.2

package/bundles/{chunk-VH6EDOMC.js → chunk-LHQ7WPU2.js}

@@ -39,7 +39,7 @@ import {
   declarationTransformFactory,
   isHostDirectiveMetaForGlobalMode,
   ivyTransformFactory
-} from "./chunk-3ESFLGKJ.js";
+} from "./chunk-7OQMTKOE.js";
 import {
   AbsoluteModuleStrategy,
   AliasStrategy,
@@ -89,7 +89,7 @@ import {
   toUnredirectedSourceFile,
   translateExpression,
   translateType
-} from "./chunk-6X7GQ6BQ.js";
+} from "./chunk-6IQBXGRH.js";
 import {
   ActivePerfRecorder,
   DelegatingPerfRecorder,
@@ -152,6 +152,7 @@ var EntryType;
   EntryType2["Pipe"] = "pipe";
   EntryType2["TypeAlias"] = "type_alias";
   EntryType2["UndecoratedClass"] = "undecorated_class";
+  EntryType2["InitializerApiFunction"] = "initializer_api_function";
 })(EntryType || (EntryType = {}));
 var MemberType;
 (function(MemberType2) {
@@ -179,284 +180,11 @@ var MemberTags;
   MemberTags2["Inherited"] = "override";
 })(MemberTags || (MemberTags = {}));
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/program.mjs
-import { HtmlParser, MessageBundle } from "@angular/compiler";
-import ts40 from "typescript";
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/i18n.mjs
-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("/");
-  };
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/typescript_support.mjs
-import ts2 from "typescript";
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/version_helpers.mjs
-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));
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/typescript_support.mjs
-var MIN_TS_VERSION = "5.2.0";
-var MAX_TS_VERSION = "5.5.0";
-var tsVersion = ts2.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);
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/src/compiler.mjs
-import { R3Identifiers as R3Identifiers5 } from "@angular/compiler";
-import ts38 from "typescript";
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/cycles/src/analyzer.mjs
-var CycleAnalyzer = class {
-  constructor(importGraph) {
-    this.importGraph = importGraph;
-    this.cachedResults = null;
-  }
-  wouldCreateCycle(from, to) {
-    if (this.cachedResults === null || this.cachedResults.from !== from) {
-      this.cachedResults = new CycleResults(from, this.importGraph);
-    }
-    return this.cachedResults.wouldBeCyclic(to) ? new Cycle(this.importGraph, from, to) : null;
-  }
-  recordSyntheticImport(from, to) {
-    this.cachedResults = null;
-    this.importGraph.addSyntheticImport(from, to);
-  }
-};
-var NgCyclicResult = Symbol("NgCyclicResult");
-var CycleResults = class {
-  constructor(from, importGraph) {
-    this.from = from;
-    this.importGraph = importGraph;
-    this.cyclic = {};
-    this.acyclic = {};
-  }
-  wouldBeCyclic(sf) {
-    const cached = this.getCachedResult(sf);
-    if (cached !== null) {
-      return cached;
-    }
-    if (sf === this.from) {
-      return true;
-    }
-    this.markAcyclic(sf);
-    const imports = this.importGraph.importsOf(sf);
-    for (const imported of imports) {
-      if (this.wouldBeCyclic(imported)) {
-        this.markCyclic(sf);
-        return true;
-      }
-    }
-    return false;
-  }
-  getCachedResult(sf) {
-    const result = sf[NgCyclicResult];
-    if (result === this.cyclic) {
-      return true;
-    } else if (result === this.acyclic) {
-      return false;
-    } else {
-      return null;
-    }
-  }
-  markCyclic(sf) {
-    sf[NgCyclicResult] = this.cyclic;
-  }
-  markAcyclic(sf) {
-    sf[NgCyclicResult] = this.acyclic;
-  }
-};
-var Cycle = class {
-  constructor(importGraph, from, to) {
-    this.importGraph = importGraph;
-    this.from = from;
-    this.to = to;
-  }
-  getPath() {
-    return [this.from, ...this.importGraph.findPath(this.to, this.from)];
-  }
-};
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/cycles/src/imports.mjs
-import ts3 from "typescript";
-var ImportGraph = class {
-  constructor(checker, perf) {
-    this.checker = checker;
-    this.perf = perf;
-    this.imports = /* @__PURE__ */ new Map();
-  }
-  importsOf(sf) {
-    if (!this.imports.has(sf)) {
-      this.imports.set(sf, this.scanImports(sf));
-    }
-    return this.imports.get(sf);
-  }
-  findPath(start, end) {
-    if (start === end) {
-      return [start];
-    }
-    const found = /* @__PURE__ */ new Set([start]);
-    const queue = [new Found(start, null)];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const imports = this.importsOf(current.sourceFile);
-      for (const importedFile of imports) {
-        if (!found.has(importedFile)) {
-          const next = new Found(importedFile, current);
-          if (next.sourceFile === end) {
-            return next.toPath();
-          }
-          found.add(importedFile);
-          queue.push(next);
-        }
-      }
-    }
-    return null;
-  }
-  addSyntheticImport(sf, imported) {
-    if (isLocalFile(imported)) {
-      this.importsOf(sf).add(imported);
-    }
-  }
-  scanImports(sf) {
-    return this.perf.inPhase(PerfPhase.CycleDetection, () => {
-      const imports = /* @__PURE__ */ new Set();
-      for (const stmt of sf.statements) {
-        if (!ts3.isImportDeclaration(stmt) && !ts3.isExportDeclaration(stmt) || stmt.moduleSpecifier === void 0) {
-          continue;
-        }
-        if (ts3.isImportDeclaration(stmt) && stmt.importClause !== void 0 && isTypeOnlyImportClause(stmt.importClause)) {
-          continue;
-        }
-        const symbol = this.checker.getSymbolAtLocation(stmt.moduleSpecifier);
-        if (symbol === void 0 || symbol.valueDeclaration === void 0) {
-          continue;
-        }
-        const moduleFile = symbol.valueDeclaration;
-        if (ts3.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
-          imports.add(moduleFile);
-        }
-      }
-      return imports;
-    });
-  }
-};
-function isLocalFile(sf) {
-  return !sf.isDeclarationFile;
-}
-function isTypeOnlyImportClause(node) {
-  if (node.isTypeOnly) {
-    return true;
-  }
-  if (node.namedBindings !== void 0 && ts3.isNamedImports(node.namedBindings) && node.namedBindings.elements.every((specifier) => specifier.isTypeOnly)) {
-    return true;
-  }
-  return false;
-}
-var Found = class {
-  constructor(sourceFile, parent) {
-    this.sourceFile = sourceFile;
-    this.parent = parent;
-  }
-  toPath() {
-    const array = [];
-    let current = this;
-    while (current !== null) {
-      array.push(current.sourceFile);
-      current = current.parent;
-    }
-    return array.reverse();
-  }
-};
-
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/extractor.mjs
-import ts10 from "typescript";
+import ts9 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/class_extractor.mjs
-import ts6 from "typescript";
+import ts4 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/filters.mjs
 function isAngularPrivateName(name) {
@@ -466,7 +194,7 @@ function isAngularPrivateName(name) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/function_extractor.mjs
-import ts5 from "typescript";
+import ts3 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/generics_extractor.mjs
 function extractGenerics(declaration) {
@@ -482,41 +210,41 @@ function extractGenerics(declaration) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/jsdoc_extractor.mjs
-import ts4 from "typescript";
+import ts2 from "typescript";
 var decoratorExpression = /@(?=(Injectable|Component|Directive|Pipe|NgModule|Input|Output|HostBinding|HostListener|Inject|Optional|Self|Host|SkipSelf))/g;
 function extractJsDocTags(node) {
   const escapedNode = getEscapedNode(node);
-  return ts4.getJSDocTags(escapedNode).map((t) => {
+  return ts2.getJSDocTags(escapedNode).map((t) => {
     var _a;
     return {
       name: t.tagName.getText(),
-      comment: unescapeAngularDecorators((_a = ts4.getTextOfJSDocComment(t.comment)) != null ? _a : "")
+      comment: unescapeAngularDecorators((_a = ts2.getTextOfJSDocComment(t.comment)) != null ? _a : "")
     };
   });
 }
 function extractJsDocDescription(node) {
   var _a, _b;
   const escapedNode = getEscapedNode(node);
-  const commentOrTag = ts4.getJSDocCommentsAndTags(escapedNode).find((d) => {
-    return ts4.isJSDoc(d) || ts4.isJSDocParameterTag(d);
+  const commentOrTag = ts2.getJSDocCommentsAndTags(escapedNode).find((d) => {
+    return ts2.isJSDoc(d) || ts2.isJSDocParameterTag(d);
   });
   const comment = (_a = commentOrTag == null ? void 0 : commentOrTag.comment) != null ? _a : "";
-  const description = typeof comment === "string" ? comment : (_b = ts4.getTextOfJSDocComment(comment)) != null ? _b : "";
+  const description = typeof comment === "string" ? comment : (_b = ts2.getTextOfJSDocComment(comment)) != null ? _b : "";
   return unescapeAngularDecorators(description);
 }
 function extractRawJsDoc(node) {
   var _a, _b;
-  const comment = (_b = (_a = ts4.getJSDocCommentsAndTags(node).find(ts4.isJSDoc)) == null ? void 0 : _a.getFullText()) != null ? _b : "";
+  const comment = (_b = (_a = ts2.getJSDocCommentsAndTags(node).find(ts2.isJSDoc)) == null ? void 0 : _a.getFullText()) != null ? _b : "";
   return unescapeAngularDecorators(comment);
 }
 function getEscapedNode(node) {
-  if (ts4.isParameter(node)) {
+  if (ts2.isParameter(node)) {
     return node;
   }
   const rawComment = extractRawJsDoc(node);
   const escaped = escapeAngularDecorators(rawComment);
-  const file = ts4.createSourceFile("x.ts", `${escaped}class X {}`, ts4.ScriptTarget.ES2020, true);
-  return file.statements.find((s) => ts4.isClassDeclaration(s));
+  const file = ts2.createSourceFile("x.ts", `${escaped}class X {}`, ts2.ScriptTarget.ES2020, true);
+  return file.statements.find((s) => ts2.isClassDeclaration(s));
 }
 function escapeAngularDecorators(comment) {
   return comment.replace(decoratorExpression, "_NG_AT_");
@@ -541,9 +269,9 @@ var FunctionExtractor = class {
     const signature = this.typeChecker.getSignatureFromDeclaration(this.declaration);
     const returnType = signature ? this.typeChecker.typeToString(this.typeChecker.getReturnTypeOfSignature(signature)) : "unknown";
     return {
-      params: this.extractAllParams(this.declaration.parameters),
+      params: extractAllParams(this.declaration.parameters, this.typeChecker),
       name: this.name,
-      isNewType: ts5.isConstructSignatureDeclaration(this.declaration),
+      isNewType: ts3.isConstructSignatureDeclaration(this.declaration),
       returnType,
       entryType: EntryType.Function,
       generics: extractGenerics(this.declaration),
@@ -552,15 +280,6 @@ var FunctionExtractor = class {
       rawComment: extractRawJsDoc(this.declaration)
     };
   }
-  extractAllParams(params) {
-    return params.map((param) => ({
-      name: param.name.getText(),
-      description: extractJsDocDescription(param),
-      type: extractResolvedTypeString(param, this.typeChecker),
-      isOptional: !!(param.questionToken || param.initializer),
-      isRestParam: !!param.dotDotDotToken
-    }));
-  }
   getOverloads() {
     var _a, _b, _c, _d;
     const overloads = [];
@@ -571,7 +290,7 @@ var FunctionExtractor = class {
         const overloadDeclaration = (_c = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _c[i];
         if ((overloadDeclaration == null ? void 0 : overloadDeclaration.pos) === this.declaration.pos)
           continue;
-        if (overloadDeclaration && ts5.isFunctionDeclaration(overloadDeclaration) && ((_d = overloadDeclaration.modifiers) == null ? void 0 : _d.some((mod) => mod.kind === ts5.SyntaxKind.ExportKeyword))) {
+        if (overloadDeclaration && ts3.isFunctionDeclaration(overloadDeclaration) && ((_d = overloadDeclaration.modifiers) == null ? void 0 : _d.some((mod) => mod.kind === ts3.SyntaxKind.ExportKeyword))) {
           overloads.push(overloadDeclaration);
         }
       }
@@ -579,12 +298,21 @@ var FunctionExtractor = class {
     return overloads;
   }
   getSymbol() {
-    return this.typeChecker.getSymbolsInScope(this.declaration, ts5.SymbolFlags.Function).find((s) => {
+    return this.typeChecker.getSymbolsInScope(this.declaration, ts3.SymbolFlags.Function).find((s) => {
       var _a;
       return s.name === ((_a = this.declaration.name) == null ? void 0 : _a.getText());
     });
   }
 };
+function extractAllParams(params, typeChecker) {
+  return params.map((param) => ({
+    name: param.name.getText(),
+    description: extractJsDocDescription(param),
+    type: extractResolvedTypeString(param, typeChecker),
+    isOptional: !!(param.questionToken || param.initializer),
+    isRestParam: !!param.dotDotDotToken
+  }));
+}
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/class_extractor.mjs
 var ClassExtractor = class {
@@ -596,7 +324,7 @@ var ClassExtractor = class {
     return {
       name: this.declaration.name.text,
       isAbstract: this.isAbstract(),
-      entryType: ts6.isInterfaceDeclaration(this.declaration) ? EntryType.Interface : EntryType.UndecoratedClass,
+      entryType: ts4.isInterfaceDeclaration(this.declaration) ? EntryType.Interface : EntryType.UndecoratedClass,
       members: this.extractSignatures().concat(this.extractAllClassMembers()),
       generics: extractGenerics(this.declaration),
       description: extractJsDocDescription(this.declaration),
@@ -621,7 +349,7 @@ var ClassExtractor = class {
       return this.extractMethod(memberDeclaration);
     } else if (this.isProperty(memberDeclaration)) {
       return this.extractClassProperty(memberDeclaration);
-    } else if (ts6.isAccessor(memberDeclaration)) {
+    } else if (ts4.isAccessor(memberDeclaration)) {
       return this.extractGetterSetter(memberDeclaration);
     }
     return void 0;
@@ -638,7 +366,7 @@ var ClassExtractor = class {
     };
   }
   extractSignature(signature) {
-    const functionExtractor = new FunctionExtractor(ts6.isConstructSignatureDeclaration(signature) ? "new" : "", signature, this.typeChecker);
+    const functionExtractor = new FunctionExtractor(ts4.isConstructSignatureDeclaration(signature) ? "new" : "", signature, this.typeChecker);
     return {
       ...functionExtractor.extract(),
       memberType: MemberType.Method,
@@ -658,7 +386,7 @@ var ClassExtractor = class {
   extractGetterSetter(accessor) {
     return {
       ...this.extractClassProperty(accessor),
-      memberType: ts6.isGetAccessor(accessor) ? MemberType.Getter : MemberType.Setter
+      memberType: ts4.isGetAccessor(accessor) ? MemberType.Getter : MemberType.Setter
     };
   }
   getMemberTags(member) {
@@ -715,13 +443,13 @@ var ClassExtractor = class {
   }
   getTagForMemberModifier(mod) {
     switch (mod.kind) {
-      case ts6.SyntaxKind.StaticKeyword:
+      case ts4.SyntaxKind.StaticKeyword:
         return MemberTags.Static;
-      case ts6.SyntaxKind.ReadonlyKeyword:
+      case ts4.SyntaxKind.ReadonlyKeyword:
         return MemberTags.Readonly;
-      case ts6.SyntaxKind.ProtectedKeyword:
+      case ts4.SyntaxKind.ProtectedKeyword:
         return MemberTags.Protected;
-      case ts6.SyntaxKind.AbstractKeyword:
+      case ts4.SyntaxKind.AbstractKeyword:
         return MemberTags.Abstract;
       default:
         return void 0;
@@ -729,27 +457,27 @@ var ClassExtractor = class {
   }
   isMemberExcluded(member) {
     var _a;
-    return !member.name || !this.isDocumentableMember(member) || !!((_a = member.modifiers) == null ? void 0 : _a.some((mod) => mod.kind === ts6.SyntaxKind.PrivateKeyword)) || member.name.getText() === "prototype" || isAngularPrivateName(member.name.getText());
+    return !member.name || !this.isDocumentableMember(member) || !!((_a = member.modifiers) == null ? void 0 : _a.some((mod) => mod.kind === ts4.SyntaxKind.PrivateKeyword)) || member.name.getText() === "prototype" || isAngularPrivateName(member.name.getText());
   }
   isDocumentableMember(member) {
-    return this.isMethod(member) || this.isProperty(member) || ts6.isAccessor(member);
+    return this.isMethod(member) || this.isProperty(member) || ts4.isAccessor(member);
   }
   isProperty(member) {
-    return ts6.isPropertyDeclaration(member) || ts6.isPropertySignature(member);
+    return ts4.isPropertyDeclaration(member) || ts4.isPropertySignature(member);
   }
   isMethod(member) {
-    return ts6.isMethodDeclaration(member) || ts6.isMethodSignature(member);
+    return ts4.isMethodDeclaration(member) || ts4.isMethodSignature(member);
   }
   isDocumentableSignature(signature) {
-    return ts6.isConstructSignatureDeclaration(signature) || ts6.isCallSignatureDeclaration(signature);
+    return ts4.isConstructSignatureDeclaration(signature) || ts4.isCallSignatureDeclaration(signature);
   }
   isAbstract() {
     var _a;
     const modifiers = (_a = this.declaration.modifiers) != null ? _a : [];
-    return modifiers.some((mod) => mod.kind === ts6.SyntaxKind.AbstractKeyword);
+    return modifiers.some((mod) => mod.kind === ts4.SyntaxKind.AbstractKeyword);
   }
   isImplementationForOverload(method) {
-    if (method.kind === ts6.SyntaxKind.MethodSignature)
+    if (method.kind === ts4.SyntaxKind.MethodSignature)
       return false;
     const signature = this.typeChecker.getSignatureFromDeclaration(method);
     return signature && this.typeChecker.isImplementationOfOverload(signature.declaration);
@@ -848,7 +576,7 @@ function extractInterface(declaration, typeChecker) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/constant_extractor.mjs
-import ts7 from "typescript";
+import ts5 from "typescript";
 var LITERAL_AS_ENUM_TAG = "object-literal-as-enum";
 function extractConstant(declaration, typeChecker) {
   const resolvedType = typeChecker.getBaseTypeOfLiteralType(typeChecker.getTypeAtLocation(declaration));
@@ -880,17 +608,17 @@ function isSyntheticAngularConstant(declaration) {
 }
 function extractLiteralPropertiesAsEnumMembers(declaration) {
   let initializer = declaration.initializer;
-  while (initializer && (ts7.isAsExpression(initializer) || ts7.isParenthesizedExpression(initializer))) {
+  while (initializer && (ts5.isAsExpression(initializer) || ts5.isParenthesizedExpression(initializer))) {
     initializer = initializer.expression;
   }
-  if (initializer === void 0 || !ts7.isObjectLiteralExpression(initializer)) {
-    throw new Error(`Declaration tagged with "${LITERAL_AS_ENUM_TAG}" must be initialized to an object literal, but received ${initializer ? ts7.SyntaxKind[initializer.kind] : "undefined"}`);
+  if (initializer === void 0 || !ts5.isObjectLiteralExpression(initializer)) {
+    throw new Error(`Declaration tagged with "${LITERAL_AS_ENUM_TAG}" must be initialized to an object literal, but received ${initializer ? ts5.SyntaxKind[initializer.kind] : "undefined"}`);
   }
   return initializer.properties.map((prop) => {
-    if (!ts7.isPropertyAssignment(prop) || !ts7.isIdentifier(prop.name)) {
+    if (!ts5.isPropertyAssignment(prop) || !ts5.isIdentifier(prop.name)) {
       throw new Error(`Property in declaration tagged with "${LITERAL_AS_ENUM_TAG}" must be a property assignment with a static name`);
     }
-    if (!ts7.isNumericLiteral(prop.initializer) && !ts7.isStringLiteralLike(prop.initializer)) {
+    if (!ts5.isNumericLiteral(prop.initializer) && !ts5.isStringLiteralLike(prop.initializer)) {
       throw new Error(`Property in declaration tagged with "${LITERAL_AS_ENUM_TAG}" must be initialized to a number or string literal`);
     }
     return {
@@ -906,7 +634,7 @@ function extractLiteralPropertiesAsEnumMembers(declaration) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/decorator_extractor.mjs
-import ts8 from "typescript";
+import ts6 from "typescript";
 function extractorDecorator(declaration, typeChecker) {
   const documentedNode = getDecoratorJsDocNode(declaration);
   const decoratorType = getDecoratorType(declaration);
@@ -927,7 +655,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) => ts6.isVariableStatement(s) && s.declarationList.declarations.some((d) => isDecoratorDeclaration(d) && d.name.getText() === declaration.name.getText()));
 }
 function getDecoratorType(declaration) {
   var _a, _b;
@@ -944,19 +672,19 @@ function getDecoratorOptions(declaration, typeChecker) {
   var _a, _b;
   const name = declaration.name.getText();
   const optionsDeclaration = declaration.getSourceFile().statements.find((node) => {
-    return (ts8.isInterfaceDeclaration(node) || ts8.isTypeAliasDeclaration(node)) && node.name.getText() === name;
+    return (ts6.isInterfaceDeclaration(node) || ts6.isTypeAliasDeclaration(node)) && node.name.getText() === name;
   });
   if (!optionsDeclaration) {
     throw new Error(`Decorator "${name}" has no corresponding options interface.`);
   }
   let optionsInterface;
-  if (ts8.isTypeAliasDeclaration(optionsDeclaration)) {
+  if (ts6.isTypeAliasDeclaration(optionsDeclaration)) {
     const aliasedType = typeChecker.getTypeAtLocation(optionsDeclaration.type);
-    optionsInterface = ((_b = (_a = aliasedType.getSymbol()) == null ? void 0 : _a.getDeclarations()) != null ? _b : []).find((d) => ts8.isInterfaceDeclaration(d));
+    optionsInterface = ((_b = (_a = aliasedType.getSymbol()) == null ? void 0 : _a.getDeclarations()) != null ? _b : []).find((d) => ts6.isInterfaceDeclaration(d));
   } else {
     optionsInterface = optionsDeclaration;
   }
-  if (!optionsInterface || !ts8.isInterfaceDeclaration(optionsInterface)) {
+  if (!optionsInterface || !ts6.isInterfaceDeclaration(optionsInterface)) {
     throw new Error(`Options for decorator "${name}" is not an interface.`);
   }
   return extractInterface(optionsInterface, typeChecker).members;
@@ -964,127 +692,548 @@ function getDecoratorOptions(declaration, typeChecker) {
 function getDecoratorJsDocNode(declaration) {
   const name = declaration.name.getText();
   const decoratorInterface = declaration.getSourceFile().statements.find((s) => {
-    return ts8.isInterfaceDeclaration(s) && s.name.getText() === `${name}Decorator`;
+    return ts6.isInterfaceDeclaration(s) && s.name.getText() === `${name}Decorator`;
   });
-  if (!decoratorInterface || !ts8.isInterfaceDeclaration(decoratorInterface)) {
+  if (!decoratorInterface || !ts6.isInterfaceDeclaration(decoratorInterface)) {
     throw new Error(`No interface "${name}Decorator" found.`);
   }
   const callSignature = decoratorInterface.members.find((node) => {
-    return ts8.isCallSignatureDeclaration(node) && extractRawJsDoc(node);
+    return ts6.isCallSignatureDeclaration(node) && extractRawJsDoc(node);
   });
-  if (!callSignature || !ts8.isCallSignatureDeclaration(callSignature)) {
+  if (!callSignature || !ts6.isCallSignatureDeclaration(callSignature)) {
     throw new Error(`No call signature with JsDoc on "${name}Decorator"`);
   }
-  return callSignature;
+  return callSignature;
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/enum_extractor.mjs
+import ts7 from "typescript";
+function extractEnum(declaration, typeChecker) {
+  return {
+    name: declaration.name.getText(),
+    entryType: EntryType.Enum,
+    members: extractEnumMembers(declaration, typeChecker),
+    rawComment: extractRawJsDoc(declaration),
+    description: extractJsDocDescription(declaration),
+    jsdocTags: extractJsDocTags(declaration)
+  };
+}
+function extractEnumMembers(declaration, checker) {
+  return declaration.members.map((member) => ({
+    name: member.name.getText(),
+    type: extractResolvedTypeString(member, checker),
+    value: getEnumMemberValue(member),
+    memberType: MemberType.EnumItem,
+    jsdocTags: extractJsDocTags(member),
+    description: extractJsDocDescription(member),
+    memberTags: []
+  }));
+}
+function getEnumMemberValue(memberNode) {
+  var _a;
+  const literal = memberNode.getChildren().find((n2) => {
+    return ts7.isNumericLiteral(n2) || ts7.isStringLiteral(n2) || ts7.isPrefixUnaryExpression(n2) && n2.operator === ts7.SyntaxKind.MinusToken && ts7.isNumericLiteral(n2.operand);
+  });
+  return (_a = literal == null ? void 0 : literal.getText()) != null ? _a : "";
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/initializer_api_function_extractor.mjs
+import ts8 from "typescript";
+var initializerApiTag = "initializerApiFunction";
+function isInitializerApiFunction(node, typeChecker) {
+  if (ts8.isFunctionDeclaration(node) && node.name !== void 0 && node.body === void 0) {
+    const implementation = findImplementationOfFunction(node, typeChecker);
+    if (implementation !== void 0) {
+      node = implementation;
+    }
+  }
+  if (!ts8.isFunctionDeclaration(node) && !ts8.isVariableDeclaration(node)) {
+    return false;
+  }
+  let tagContainer = ts8.isFunctionDeclaration(node) ? node : getContainerVariableStatement(node);
+  if (tagContainer === null) {
+    return false;
+  }
+  const tags = ts8.getJSDocTags(tagContainer);
+  return tags.some((t) => t.tagName.text === initializerApiTag);
+}
+function extractInitializerApiFunction(node, typeChecker) {
+  var _a;
+  if (node.name === void 0 || !ts8.isIdentifier(node.name)) {
+    throw new Error(`Initializer API: Expected literal variable name.`);
+  }
+  const container = ts8.isFunctionDeclaration(node) ? node : getContainerVariableStatement(node);
+  if (container === null) {
+    throw new Error("Initializer API: Could not find container AST node of variable.");
+  }
+  const name = node.name.text;
+  const type = typeChecker.getTypeAtLocation(node);
+  const callFunction = extractFunctionWithOverloads(name, type.getCallSignatures(), typeChecker);
+  const subFunctions = [];
+  for (const property of type.getProperties()) {
+    const subName = property.getName();
+    const subDecl = (_a = property.getDeclarations()) == null ? void 0 : _a[0];
+    if (subDecl === void 0 || !ts8.isPropertySignature(subDecl)) {
+      throw new Error(`Initializer API: Could not resolve declaration of sub-property: ${name}.${subName}`);
+    }
+    const subType = typeChecker.getTypeAtLocation(subDecl);
+    subFunctions.push(extractFunctionWithOverloads(subName, subType.getCallSignatures(), typeChecker));
+  }
+  let jsdocTags;
+  let description;
+  let rawComment;
+  if (ts8.isFunctionDeclaration(node)) {
+    const implementation = findImplementationOfFunction(node, typeChecker);
+    if (implementation === void 0) {
+      throw new Error(`Initializer API: Could not find implementation of function: ${name}`);
+    }
+    callFunction.implementation = {
+      name,
+      entryType: EntryType.Function,
+      isNewType: false,
+      description: extractJsDocDescription(implementation),
+      generics: extractGenerics(implementation),
+      jsdocTags: extractJsDocTags(implementation),
+      params: extractAllParams(implementation.parameters, typeChecker),
+      rawComment: extractRawJsDoc(implementation),
+      returnType: typeChecker.typeToString(typeChecker.getReturnTypeOfSignature(typeChecker.getSignatureFromDeclaration(implementation)))
+    };
+    jsdocTags = callFunction.implementation.jsdocTags;
+    description = callFunction.implementation.description;
+    rawComment = callFunction.implementation.description;
+  } else {
+    jsdocTags = extractJsDocTags(container);
+    description = extractJsDocDescription(container);
+    rawComment = extractRawJsDoc(container);
+  }
+  const metadataTag = jsdocTags.find((t) => t.name === initializerApiTag);
+  if (metadataTag === void 0) {
+    throw new Error(`Initializer API: Detected initializer API function does not have "@initializerApiFunction" tag: ${name}`);
+  }
+  let parsedMetadata = void 0;
+  if (metadataTag.comment.trim() !== "") {
+    try {
+      parsedMetadata = JSON.parse(metadataTag.comment);
+    } catch (e) {
+      throw new Error(`Could not parse initializer API function metadata: ${e}`);
+    }
+  }
+  return {
+    entryType: EntryType.InitializerApiFunction,
+    name,
+    description,
+    jsdocTags,
+    rawComment,
+    callFunction,
+    subFunctions,
+    __docsMetadata__: parsedMetadata
+  };
+}
+function getContainerVariableStatement(node) {
+  if (!ts8.isVariableDeclarationList(node.parent)) {
+    return null;
+  }
+  if (!ts8.isVariableStatement(node.parent.parent)) {
+    return null;
+  }
+  return node.parent.parent;
+}
+function filterSignatureDeclarations(signatures) {
+  const result = [];
+  for (const signature of signatures) {
+    const decl = signature.getDeclaration();
+    if (ts8.isFunctionDeclaration(decl) || ts8.isCallSignatureDeclaration(decl)) {
+      result.push(decl);
+    }
+  }
+  return result;
+}
+function extractFunctionWithOverloads(name, signatures, typeChecker) {
+  return {
+    name,
+    signatures: filterSignatureDeclarations(signatures).map((s) => ({
+      name,
+      entryType: EntryType.Function,
+      description: extractJsDocDescription(s),
+      generics: extractGenerics(s),
+      isNewType: false,
+      jsdocTags: extractJsDocTags(s),
+      params: extractAllParams(s.parameters, typeChecker),
+      rawComment: extractRawJsDoc(s),
+      returnType: typeChecker.typeToString(typeChecker.getReturnTypeOfSignature(typeChecker.getSignatureFromDeclaration(s)))
+    })),
+    implementation: null
+  };
+}
+function findImplementationOfFunction(node, typeChecker) {
+  var _a;
+  if (node.body !== void 0 || node.name === void 0) {
+    return node;
+  }
+  const symbol = typeChecker.getSymbolAtLocation(node.name);
+  return (_a = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a.find((s) => ts8.isFunctionDeclaration(s) && s.body !== void 0);
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/type_alias_extractor.mjs
+function extractTypeAlias(declaration) {
+  return {
+    name: declaration.name.getText(),
+    type: declaration.type.getText(),
+    entryType: EntryType.TypeAlias,
+    rawComment: extractRawJsDoc(declaration),
+    description: extractJsDocDescription(declaration),
+    jsdocTags: extractJsDocTags(declaration)
+  };
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/extractor.mjs
+var DocsExtractor = class {
+  constructor(typeChecker, metadataReader) {
+    this.typeChecker = typeChecker;
+    this.metadataReader = metadataReader;
+  }
+  extractAll(sourceFile) {
+    const entries = [];
+    const exportedDeclarations = this.getExportedDeclarations(sourceFile);
+    for (const [exportName, node] of exportedDeclarations) {
+      if (isAngularPrivateName(exportName)) {
+        continue;
+      }
+      const entry = this.extractDeclaration(node);
+      if (entry && !isIgnoredDocEntry(entry)) {
+        entries.push({ ...entry, name: exportName });
+      }
+    }
+    return entries;
+  }
+  extractDeclaration(node) {
+    if (isNamedClassDeclaration(node)) {
+      return extractClass(node, this.metadataReader, this.typeChecker);
+    }
+    if (isInitializerApiFunction(node, this.typeChecker)) {
+      return extractInitializerApiFunction(node, this.typeChecker);
+    }
+    if (ts9.isInterfaceDeclaration(node) && !isIgnoredInterface(node)) {
+      return extractInterface(node, this.typeChecker);
+    }
+    if (ts9.isFunctionDeclaration(node)) {
+      const functionExtractor = new FunctionExtractor(node.name.getText(), node, this.typeChecker);
+      return functionExtractor.extract();
+    }
+    if (ts9.isVariableDeclaration(node) && !isSyntheticAngularConstant(node)) {
+      return isDecoratorDeclaration(node) ? extractorDecorator(node, this.typeChecker) : extractConstant(node, this.typeChecker);
+    }
+    if (ts9.isTypeAliasDeclaration(node)) {
+      return extractTypeAlias(node);
+    }
+    if (ts9.isEnumDeclaration(node)) {
+      return extractEnum(node, this.typeChecker);
+    }
+    return null;
+  }
+  getExportedDeclarations(sourceFile) {
+    var _a;
+    const reflector = new TypeScriptReflectionHost(this.typeChecker);
+    const exportedDeclarationMap = reflector.getExportsOfModule(sourceFile);
+    let exportedDeclarations = Array.from((_a = exportedDeclarationMap == null ? void 0 : exportedDeclarationMap.entries()) != null ? _a : []).map(([exportName, declaration]) => [exportName, declaration.node]);
+    const declarationCount = exportedDeclarations.length;
+    for (let i = 0; i < declarationCount; i++) {
+      const [exportName, declaration] = exportedDeclarations[i];
+      if (ts9.isFunctionDeclaration(declaration)) {
+        const extractor = new FunctionExtractor(exportName, declaration, this.typeChecker);
+        const overloads = extractor.getOverloads().map((overload) => [exportName, overload]);
+        exportedDeclarations.push(...overloads);
+      }
+    }
+    return exportedDeclarations.sort(([a, declarationA], [b, declarationB]) => declarationA.pos - declarationB.pos);
+  }
+};
+function isIgnoredInterface(node) {
+  return node.name.getText().endsWith("Decorator") || isDecoratorOptionsInterface(node);
+}
+function isIgnoredDocEntry(entry) {
+  const isDocsPrivate = entry.jsdocTags.find((e) => e.name === "docsPrivate");
+  if (isDocsPrivate !== void 0 && isDocsPrivate.comment === "") {
+    throw new Error(`Docs extraction: Entry "${entry.name}" is marked as "@docsPrivate" but without reasoning.`);
+  }
+  return isDocsPrivate !== void 0;
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/program.mjs
+import { HtmlParser, MessageBundle } from "@angular/compiler";
+import ts41 from "typescript";
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/i18n.mjs
+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("/");
+  };
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/typescript_support.mjs
+import ts10 from "typescript";
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/version_helpers.mjs
+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;
 }
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/enum_extractor.mjs
-import ts9 from "typescript";
-function extractEnum(declaration, typeChecker) {
-  return {
-    name: declaration.name.getText(),
-    entryType: EntryType.Enum,
-    members: extractEnumMembers(declaration, typeChecker),
-    rawComment: extractRawJsDoc(declaration),
-    description: extractJsDocDescription(declaration),
-    jsdocTags: extractJsDocTags(declaration)
-  };
+function compareVersions(v1, v2) {
+  return compareNumbers(toNumbers(v1), toNumbers(v2));
 }
-function extractEnumMembers(declaration, checker) {
-  return declaration.members.map((member) => ({
-    name: member.name.getText(),
-    type: extractResolvedTypeString(member, checker),
-    value: getEnumMemberValue(member),
-    memberType: MemberType.EnumItem,
-    jsdocTags: extractJsDocTags(member),
-    description: extractJsDocDescription(member),
-    memberTags: []
-  }));
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/typescript_support.mjs
+var MIN_TS_VERSION = "5.2.0";
+var MAX_TS_VERSION = "5.5.0";
+var tsVersion = ts10.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 getEnumMemberValue(memberNode) {
-  var _a;
-  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 (_a = literal == null ? void 0 : literal.getText()) != null ? _a : "";
+function verifySupportedTypeScriptVersion() {
+  checkVersion(tsVersion, MIN_TS_VERSION, MAX_TS_VERSION);
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/type_alias_extractor.mjs
-function extractTypeAlias(declaration) {
-  return {
-    name: declaration.name.getText(),
-    type: declaration.type.getText(),
-    entryType: EntryType.TypeAlias,
-    rawComment: extractRawJsDoc(declaration),
-    description: extractJsDocDescription(declaration),
-    jsdocTags: extractJsDocTags(declaration)
-  };
-}
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/src/compiler.mjs
+import { R3Identifiers as R3Identifiers5 } from "@angular/compiler";
+import ts39 from "typescript";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/docs/src/extractor.mjs
-var DocsExtractor = class {
-  constructor(typeChecker, metadataReader) {
-    this.typeChecker = typeChecker;
-    this.metadataReader = metadataReader;
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/cycles/src/analyzer.mjs
+var CycleAnalyzer = class {
+  constructor(importGraph) {
+    this.importGraph = importGraph;
+    this.cachedResults = null;
   }
-  extractAll(sourceFile) {
-    const entries = [];
-    const exportedDeclarations = this.getExportedDeclarations(sourceFile);
-    for (const [exportName, node] of exportedDeclarations) {
-      if (isAngularPrivateName(exportName))
-        continue;
-      const entry = this.extractDeclaration(node);
-      if (entry) {
-        entries.push({ ...entry, name: exportName });
-      }
+  wouldCreateCycle(from, to) {
+    if (this.cachedResults === null || this.cachedResults.from !== from) {
+      this.cachedResults = new CycleResults(from, this.importGraph);
     }
-    return entries;
+    return this.cachedResults.wouldBeCyclic(to) ? new Cycle(this.importGraph, from, to) : null;
   }
-  extractDeclaration(node) {
-    if (isNamedClassDeclaration(node)) {
-      return extractClass(node, this.metadataReader, this.typeChecker);
+  recordSyntheticImport(from, to) {
+    this.cachedResults = null;
+    this.importGraph.addSyntheticImport(from, to);
+  }
+};
+var NgCyclicResult = Symbol("NgCyclicResult");
+var CycleResults = class {
+  constructor(from, importGraph) {
+    this.from = from;
+    this.importGraph = importGraph;
+    this.cyclic = {};
+    this.acyclic = {};
+  }
+  wouldBeCyclic(sf) {
+    const cached = this.getCachedResult(sf);
+    if (cached !== null) {
+      return cached;
     }
-    if (ts10.isInterfaceDeclaration(node) && !isIgnoredInterface(node)) {
-      return extractInterface(node, this.typeChecker);
+    if (sf === this.from) {
+      return true;
     }
-    if (ts10.isFunctionDeclaration(node)) {
-      const functionExtractor = new FunctionExtractor(node.name.getText(), node, this.typeChecker);
-      return functionExtractor.extract();
+    this.markAcyclic(sf);
+    const imports = this.importGraph.importsOf(sf);
+    for (const imported of imports) {
+      if (this.wouldBeCyclic(imported)) {
+        this.markCyclic(sf);
+        return true;
+      }
     }
-    if (ts10.isVariableDeclaration(node) && !isSyntheticAngularConstant(node)) {
-      return isDecoratorDeclaration(node) ? extractorDecorator(node, this.typeChecker) : extractConstant(node, this.typeChecker);
+    return false;
+  }
+  getCachedResult(sf) {
+    const result = sf[NgCyclicResult];
+    if (result === this.cyclic) {
+      return true;
+    } else if (result === this.acyclic) {
+      return false;
+    } else {
+      return null;
     }
-    if (ts10.isTypeAliasDeclaration(node)) {
-      return extractTypeAlias(node);
+  }
+  markCyclic(sf) {
+    sf[NgCyclicResult] = this.cyclic;
+  }
+  markAcyclic(sf) {
+    sf[NgCyclicResult] = this.acyclic;
+  }
+};
+var Cycle = class {
+  constructor(importGraph, from, to) {
+    this.importGraph = importGraph;
+    this.from = from;
+    this.to = to;
+  }
+  getPath() {
+    return [this.from, ...this.importGraph.findPath(this.to, this.from)];
+  }
+};
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/cycles/src/imports.mjs
+import ts11 from "typescript";
+var ImportGraph = class {
+  constructor(checker, perf) {
+    this.checker = checker;
+    this.perf = perf;
+    this.imports = /* @__PURE__ */ new Map();
+  }
+  importsOf(sf) {
+    if (!this.imports.has(sf)) {
+      this.imports.set(sf, this.scanImports(sf));
     }
-    if (ts10.isEnumDeclaration(node)) {
-      return extractEnum(node, this.typeChecker);
+    return this.imports.get(sf);
+  }
+  findPath(start, end) {
+    if (start === end) {
+      return [start];
+    }
+    const found = /* @__PURE__ */ new Set([start]);
+    const queue = [new Found(start, null)];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const imports = this.importsOf(current.sourceFile);
+      for (const importedFile of imports) {
+        if (!found.has(importedFile)) {
+          const next = new Found(importedFile, current);
+          if (next.sourceFile === end) {
+            return next.toPath();
+          }
+          found.add(importedFile);
+          queue.push(next);
+        }
+      }
     }
     return null;
   }
-  getExportedDeclarations(sourceFile) {
-    var _a;
-    const reflector = new TypeScriptReflectionHost(this.typeChecker);
-    const exportedDeclarationMap = reflector.getExportsOfModule(sourceFile);
-    let exportedDeclarations = Array.from((_a = exportedDeclarationMap == null ? void 0 : exportedDeclarationMap.entries()) != null ? _a : []).map(([exportName, declaration]) => [exportName, declaration.node]);
-    const declarationCount = exportedDeclarations.length;
-    for (let i = 0; i < declarationCount; i++) {
-      const [exportName, declaration] = exportedDeclarations[i];
-      if (ts10.isFunctionDeclaration(declaration)) {
-        const extractor = new FunctionExtractor(exportName, declaration, this.typeChecker);
-        const overloads = extractor.getOverloads().map((overload) => [exportName, overload]);
-        exportedDeclarations.push(...overloads);
-      }
+  addSyntheticImport(sf, imported) {
+    if (isLocalFile(imported)) {
+      this.importsOf(sf).add(imported);
     }
-    return exportedDeclarations.sort(([a, declarationA], [b, declarationB]) => declarationA.pos - declarationB.pos);
+  }
+  scanImports(sf) {
+    return this.perf.inPhase(PerfPhase.CycleDetection, () => {
+      const imports = /* @__PURE__ */ new Set();
+      for (const stmt of sf.statements) {
+        if (!ts11.isImportDeclaration(stmt) && !ts11.isExportDeclaration(stmt) || stmt.moduleSpecifier === void 0) {
+          continue;
+        }
+        if (ts11.isImportDeclaration(stmt) && stmt.importClause !== void 0 && isTypeOnlyImportClause(stmt.importClause)) {
+          continue;
+        }
+        const symbol = this.checker.getSymbolAtLocation(stmt.moduleSpecifier);
+        if (symbol === void 0 || symbol.valueDeclaration === void 0) {
+          continue;
+        }
+        const moduleFile = symbol.valueDeclaration;
+        if (ts11.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
+          imports.add(moduleFile);
+        }
+      }
+      return imports;
+    });
   }
 };
-function isIgnoredInterface(node) {
-  return node.name.getText().endsWith("Decorator") || isDecoratorOptionsInterface(node);
+function isLocalFile(sf) {
+  return !sf.isDeclarationFile;
+}
+function isTypeOnlyImportClause(node) {
+  if (node.isTypeOnly) {
+    return true;
+  }
+  if (node.namedBindings !== void 0 && ts11.isNamedImports(node.namedBindings) && node.namedBindings.elements.every((specifier) => specifier.isTypeOnly)) {
+    return true;
+  }
+  return false;
 }
+var Found = class {
+  constructor(sourceFile, parent) {
+    this.sourceFile = sourceFile;
+    this.parent = parent;
+  }
+  toPath() {
+    const array = [];
+    let current = this;
+    while (current !== null) {
+      array.push(current.sourceFile);
+      current = current.parent;
+    }
+    return array.reverse();
+  }
+};
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/entry_point/src/generator.mjs
-import ts11 from "typescript";
+import ts12 from "typescript";
 var FlatIndexGenerator = class {
   constructor(entryPoint, relativeFlatIndexPath, moduleName) {
     this.entryPoint = entryPoint;
@@ -1100,7 +1249,7 @@ var FlatIndexGenerator = class {
 
 export * from '${relativeEntryPoint}';
 `;
-    const genFile = ts11.createSourceFile(this.flatIndexPath, contents, ts11.ScriptTarget.ES2015, true, ts11.ScriptKind.TS);
+    const genFile = ts12.createSourceFile(this.flatIndexPath, contents, ts12.ScriptTarget.ES2015, true, ts12.ScriptKind.TS);
     if (this.moduleName !== null) {
       genFile.moduleName = this.moduleName;
     }
@@ -1125,7 +1274,7 @@ function findFlatIndexEntryPoint(rootFiles) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/entry_point/src/private_export_checker.mjs
-import ts12 from "typescript";
+import ts13 from "typescript";
 function checkForPrivateExports(entryPoint, checker, refGraph) {
   const diagnostics = [];
   const topLevelExports = /* @__PURE__ */ new Set();
@@ -1135,7 +1284,7 @@ function checkForPrivateExports(entryPoint, checker, refGraph) {
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   exportedSymbols.forEach((symbol) => {
-    if (symbol.flags & ts12.SymbolFlags.Alias) {
+    if (symbol.flags & ts13.SymbolFlags.Alias) {
       symbol = checker.getAliasedSymbol(symbol);
     }
     const decl = symbol.valueDeclaration;
@@ -1159,7 +1308,7 @@ function checkForPrivateExports(entryPoint, checker, refGraph) {
           visibleVia = transitivePath.map((seg) => getNameOfDeclaration(seg)).join(" -> ");
         }
         const diagnostic = {
-          category: ts12.DiagnosticCategory.Error,
+          category: ts13.DiagnosticCategory.Error,
           code: ngErrorCode(ErrorCode.SYMBOL_NOT_EXPORTED),
           file: transitiveReference.getSourceFile(),
           ...getPosOfDeclaration(transitiveReference),
@@ -1179,7 +1328,7 @@ function getPosOfDeclaration(decl) {
   };
 }
 function getIdentifierOfDeclaration(decl) {
-  if ((ts12.isClassDeclaration(decl) || ts12.isVariableDeclaration(decl) || ts12.isFunctionDeclaration(decl)) && decl.name !== void 0 && ts12.isIdentifier(decl.name)) {
+  if ((ts13.isClassDeclaration(decl) || ts13.isVariableDeclaration(decl) || ts13.isFunctionDeclaration(decl)) && decl.name !== void 0 && ts13.isIdentifier(decl.name)) {
     return decl.name;
   } else {
     return null;
@@ -1191,13 +1340,13 @@ function getNameOfDeclaration(decl) {
 }
 function getDescriptorOfDeclaration(decl) {
   switch (decl.kind) {
-    case ts12.SyntaxKind.ClassDeclaration:
+    case ts13.SyntaxKind.ClassDeclaration:
       return "class";
-    case ts12.SyntaxKind.FunctionDeclaration:
+    case ts13.SyntaxKind.FunctionDeclaration:
       return "function";
-    case ts12.SyntaxKind.VariableDeclaration:
+    case ts13.SyntaxKind.VariableDeclaration:
       return "variable";
-    case ts12.SyntaxKind.EnumDeclaration:
+    case ts13.SyntaxKind.EnumDeclaration:
       return "enum";
     default:
       return "declaration";
@@ -1267,10 +1416,10 @@ var UpdateMode;
 })(UpdateMode || (UpdateMode = {}));
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/program_driver/src/ts_create_program_driver.mjs
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/adapter.mjs
-import ts13 from "typescript";
+import ts14 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/expando.mjs
 var NgExtension = Symbol("NgExtension");
@@ -1401,10 +1550,10 @@ var ShimAdapter = class {
       }
       const prefix = match[1];
       let baseFileName = absoluteFrom(prefix + ".ts");
-      let inputFile = this.delegate.getSourceFile(baseFileName, ts13.ScriptTarget.Latest);
+      let inputFile = this.delegate.getSourceFile(baseFileName, ts14.ScriptTarget.Latest);
       if (inputFile === void 0) {
         baseFileName = absoluteFrom(prefix + ".tsx");
-        inputFile = this.delegate.getSourceFile(baseFileName, ts13.ScriptTarget.Latest);
+        inputFile = this.delegate.getSourceFile(baseFileName, ts14.ScriptTarget.Latest);
       }
       if (inputFile === void 0 || isShim(inputFile)) {
         return void 0;
@@ -1565,7 +1714,7 @@ var TsCreateProgramDriver = class {
       this.sfMap.clear();
     }
     for (const [filePath, { newText, originalFile }] of contents.entries()) {
-      const sf = ts14.createSourceFile(filePath, newText, ts14.ScriptTarget.Latest, true);
+      const sf = ts15.createSourceFile(filePath, newText, ts15.ScriptTarget.Latest, true);
       if (originalFile !== null) {
         sf[NgOriginalFile] = originalFile;
       }
@@ -1574,7 +1723,7 @@ var TsCreateProgramDriver = class {
     const host = new UpdatedProgramHost(this.sfMap, this.originalProgram, this.originalHost, this.shimExtensionPrefixes);
     const oldProgram = this.program;
     retagAllTsFiles(oldProgram);
-    this.program = ts14.createProgram({
+    this.program = ts15.createProgram({
       host,
       rootNames: this.program.getRootFileNames(),
       options: this.options,
@@ -2337,7 +2486,7 @@ var NgModuleIndexImpl = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/resource/src/loader.mjs
-import ts15 from "typescript";
+import ts16 from "typescript";
 var CSS_PREPROCESSOR_EXT = /(\.scss|\.sass|\.less|\.styl)$/;
 var RESOURCE_MARKER = ".$ngresource$";
 var RESOURCE_MARKER_TS = RESOURCE_MARKER + ".ts";
@@ -2447,7 +2596,7 @@ var AdapterResourceLoader = class {
     return this.adapter.rootDirs.map((rootDir) => join(rootDir, segment));
   }
   getResolvedCandidateLocations(url, fromFile) {
-    const failedLookup = ts15.resolveModuleName(url + RESOURCE_MARKER, fromFile, this.options, this.lookupResolutionHost);
+    const failedLookup = ts16.resolveModuleName(url + RESOURCE_MARKER, fromFile, this.options, this.lookupResolutionHost);
     if (failedLookup.failedLookupLocations === void 0) {
       throw new Error(`Internal error: expected to find failedLookupLocations during resolution of resource '${url}' in context of ${fromFile}`);
     }
@@ -2582,7 +2731,7 @@ var StandaloneComponentScopeReader = class {
 import { CssSelector as CssSelector2, DomElementSchemaRegistry as DomElementSchemaRegistry2, ExternalExpr as ExternalExpr2, WrappedNodeExpr as WrappedNodeExpr2 } from "@angular/compiler";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/diagnostic.mjs
-import ts16 from "typescript";
+import ts17 from "typescript";
 function makeTemplateDiagnostic(templateId, mapping, span, category, code, messageText, relatedMessages) {
   var _a;
   if (mapping.type === "direct") {
@@ -2591,7 +2740,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
       relatedInformation = [];
       for (const relatedMessage of relatedMessages) {
         relatedInformation.push({
-          category: ts16.DiagnosticCategory.Message,
+          category: ts17.DiagnosticCategory.Message,
           code: 0,
           file: relatedMessage.sourceFile,
           start: relatedMessage.start,
@@ -2620,7 +2769,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
     if (relatedMessages !== void 0) {
       for (const relatedMessage of relatedMessages) {
         relatedInformation.push({
-          category: ts16.DiagnosticCategory.Message,
+          category: ts17.DiagnosticCategory.Message,
           code: 0,
           file: relatedMessage.sourceFile,
           start: relatedMessage.start,
@@ -2650,7 +2799,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
       };
     }
     relatedInformation.push({
-      category: ts16.DiagnosticCategory.Message,
+      category: ts17.DiagnosticCategory.Message,
       code: 0,
       file: componentSf,
       start: mapping.node.getStart(),
@@ -2685,7 +2834,7 @@ function parseTemplateAsSourceFile(fileName, template) {
   if (parseTemplateAsSourceFileForTest !== null) {
     return parseTemplateAsSourceFileForTest(fileName, template);
   }
-  return ts16.createSourceFile(fileName, template, ts16.ScriptTarget.Latest, false, ts16.ScriptKind.JSX);
+  return ts17.createSourceFile(fileName, template, ts17.ScriptTarget.Latest, false, ts17.ScriptKind.JSX);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/id.mjs
@@ -2707,15 +2856,15 @@ function allocateTemplateId(sf) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/completion.mjs
 import { EmptyExpr, ImplicitReceiver as ImplicitReceiver2, PropertyRead as PropertyRead2, PropertyWrite as PropertyWrite2, SafePropertyRead, TmplAstReference as TmplAstReference2, TmplAstTextAttribute } from "@angular/compiler";
-import ts18 from "typescript";
+import ts19 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/comments.mjs
 import { AbsoluteSourceSpan as AbsoluteSourceSpan2 } from "@angular/compiler";
-import ts17 from "typescript";
+import ts18 from "typescript";
 var parseSpanComment = /^(\d+),(\d+)$/;
 function readSpanComment(node, sourceFile = node.getSourceFile()) {
-  return ts17.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== ts17.SyntaxKind.MultiLineCommentTrivia) {
+  return ts18.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== ts18.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -2739,25 +2888,25 @@ var ExpressionIdentifier;
   ExpressionIdentifier2["VARIABLE_AS_EXPRESSION"] = "VAE";
 })(ExpressionIdentifier || (ExpressionIdentifier = {}));
 function addExpressionIdentifier(node, identifier) {
-  ts17.addSyntheticTrailingComment(
+  ts18.addSyntheticTrailingComment(
     node,
-    ts17.SyntaxKind.MultiLineCommentTrivia,
+    ts18.SyntaxKind.MultiLineCommentTrivia,
     `${CommentTriviaType.EXPRESSION_TYPE_IDENTIFIER}:${identifier}`,
     false
   );
 }
 var IGNORE_FOR_DIAGNOSTICS_MARKER = `${CommentTriviaType.DIAGNOSTIC}:ignore`;
 function markIgnoreDiagnostics(node) {
-  ts17.addSyntheticTrailingComment(
+  ts18.addSyntheticTrailingComment(
     node,
-    ts17.SyntaxKind.MultiLineCommentTrivia,
+    ts18.SyntaxKind.MultiLineCommentTrivia,
     IGNORE_FOR_DIAGNOSTICS_MARKER,
     false
   );
 }
 function hasIgnoreForDiagnosticsMarker(node, sourceFile) {
-  return ts17.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== ts17.SyntaxKind.MultiLineCommentTrivia) {
+  return ts18.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== ts18.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -2831,8 +2980,8 @@ function findAllMatchingNodes(tcb, opts) {
   return results;
 }
 function hasExpressionIdentifier(sourceFile, node, identifier) {
-  return ts17.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== ts17.SyntaxKind.MultiLineCommentTrivia) {
+  return ts18.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== ts18.SyntaxKind.MultiLineCommentTrivia) {
       return false;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -2850,7 +2999,7 @@ var CompletionEngine = class {
     this.templateContextCache = /* @__PURE__ */ new Map();
     this.expressionCompletionCache = /* @__PURE__ */ new Map();
     const globalRead = findFirstMatchingNode(this.tcb, {
-      filter: ts18.isPropertyAccessExpression,
+      filter: ts19.isPropertyAccessExpression,
       withExpressionIdentifier: ExpressionIdentifier.COMPONENT_COMPLETION
     });
     if (globalRead !== null) {
@@ -2874,7 +3023,7 @@ var CompletionEngine = class {
     let nodeContext = null;
     if (node instanceof EmptyExpr) {
       const nodeLocation = findFirstMatchingNode(this.tcb, {
-        filter: ts18.isIdentifier,
+        filter: ts19.isIdentifier,
         withSpan: node.sourceSpan
       });
       if (nodeLocation !== null) {
@@ -2887,7 +3036,7 @@ var CompletionEngine = class {
     }
     if (node instanceof PropertyRead2 && node.receiver instanceof ImplicitReceiver2) {
       const nodeLocation = findFirstMatchingNode(this.tcb, {
-        filter: ts18.isPropertyAccessExpression,
+        filter: ts19.isPropertyAccessExpression,
         withSpan: node.sourceSpan
       });
       if (nodeLocation) {
@@ -2911,21 +3060,21 @@ var CompletionEngine = class {
     let tsExpr = null;
     if (expr instanceof PropertyRead2 || expr instanceof PropertyWrite2) {
       tsExpr = findFirstMatchingNode(this.tcb, {
-        filter: ts18.isPropertyAccessExpression,
+        filter: ts19.isPropertyAccessExpression,
         withSpan: expr.nameSpan
       });
     } else if (expr instanceof SafePropertyRead) {
       const ternaryExpr = findFirstMatchingNode(this.tcb, {
-        filter: ts18.isParenthesizedExpression,
+        filter: ts19.isParenthesizedExpression,
         withSpan: expr.sourceSpan
       });
-      if (ternaryExpr === null || !ts18.isConditionalExpression(ternaryExpr.expression)) {
+      if (ternaryExpr === null || !ts19.isConditionalExpression(ternaryExpr.expression)) {
         return null;
       }
       const whenTrue = ternaryExpr.expression.whenTrue;
-      if (ts18.isPropertyAccessExpression(whenTrue)) {
+      if (ts19.isPropertyAccessExpression(whenTrue)) {
         tsExpr = whenTrue;
-      } else if (ts18.isCallExpression(whenTrue) && ts18.isPropertyAccessExpression(whenTrue.expression)) {
+      } else if (ts19.isCallExpression(whenTrue) && ts19.isPropertyAccessExpression(whenTrue.expression)) {
         tsExpr = whenTrue.expression;
       }
     }
@@ -2947,15 +3096,15 @@ var CompletionEngine = class {
     let tsExpr = null;
     if (expr instanceof TmplAstTextAttribute) {
       const strNode = findFirstMatchingNode(this.tcb, {
-        filter: ts18.isParenthesizedExpression,
+        filter: ts19.isParenthesizedExpression,
         withSpan: expr.sourceSpan
       });
-      if (strNode !== null && ts18.isStringLiteral(strNode.expression)) {
+      if (strNode !== null && ts19.isStringLiteral(strNode.expression)) {
         tsExpr = strNode.expression;
       }
     } else {
       tsExpr = findFirstMatchingNode(this.tcb, {
-        filter: (n) => ts18.isStringLiteral(n) || ts18.isNumericLiteral(n),
+        filter: (n2) => ts19.isStringLiteral(n2) || ts19.isNumericLiteral(n2),
         withSpan: expr.sourceSpan
       });
     }
@@ -2963,7 +3112,7 @@ var CompletionEngine = class {
       return null;
     }
     let positionInShimFile = tsExpr.getEnd();
-    if (ts18.isStringLiteral(tsExpr)) {
+    if (ts19.isStringLiteral(tsExpr)) {
       positionInShimFile -= 1;
     }
     const res = {
@@ -2997,12 +3146,1022 @@ var CompletionEngine = class {
   }
 };
 
+// node_modules/magic-string/dist/magic-string.es.mjs
+import { encode } from "@jridgewell/sourcemap-codec";
+var BitSet = class {
+  constructor(arg) {
+    this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+  }
+  add(n2) {
+    this.bits[n2 >> 5] |= 1 << (n2 & 31);
+  }
+  has(n2) {
+    return !!(this.bits[n2 >> 5] & 1 << (n2 & 31));
+  }
+};
+var Chunk = class {
+  constructor(start, end, content) {
+    this.start = start;
+    this.end = end;
+    this.original = content;
+    this.intro = "";
+    this.outro = "";
+    this.content = content;
+    this.storeName = false;
+    this.edited = false;
+    {
+      this.previous = null;
+      this.next = null;
+    }
+  }
+  appendLeft(content) {
+    this.outro += content;
+  }
+  appendRight(content) {
+    this.intro = this.intro + content;
+  }
+  clone() {
+    const chunk = new Chunk(this.start, this.end, this.original);
+    chunk.intro = this.intro;
+    chunk.outro = this.outro;
+    chunk.content = this.content;
+    chunk.storeName = this.storeName;
+    chunk.edited = this.edited;
+    return chunk;
+  }
+  contains(index) {
+    return this.start < index && index < this.end;
+  }
+  eachNext(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.next;
+    }
+  }
+  eachPrevious(fn) {
+    let chunk = this;
+    while (chunk) {
+      fn(chunk);
+      chunk = chunk.previous;
+    }
+  }
+  edit(content, storeName, contentOnly) {
+    this.content = content;
+    if (!contentOnly) {
+      this.intro = "";
+      this.outro = "";
+    }
+    this.storeName = storeName;
+    this.edited = true;
+    return this;
+  }
+  prependLeft(content) {
+    this.outro = content + this.outro;
+  }
+  prependRight(content) {
+    this.intro = content + this.intro;
+  }
+  reset() {
+    this.intro = "";
+    this.outro = "";
+    if (this.edited) {
+      this.content = this.original;
+      this.storeName = false;
+      this.edited = false;
+    }
+  }
+  split(index) {
+    const sliceIndex = index - this.start;
+    const originalBefore = this.original.slice(0, sliceIndex);
+    const originalAfter = this.original.slice(sliceIndex);
+    this.original = originalBefore;
+    const newChunk = new Chunk(index, this.end, originalAfter);
+    newChunk.outro = this.outro;
+    this.outro = "";
+    this.end = index;
+    if (this.edited) {
+      newChunk.edit("", false);
+      this.content = "";
+    } else {
+      this.content = originalBefore;
+    }
+    newChunk.next = this.next;
+    if (newChunk.next)
+      newChunk.next.previous = newChunk;
+    newChunk.previous = this;
+    this.next = newChunk;
+    return newChunk;
+  }
+  toString() {
+    return this.intro + this.content + this.outro;
+  }
+  trimEnd(rx) {
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length)
+      return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        this.split(this.start + trimmed.length).edit("", void 0, true);
+        if (this.edited) {
+          this.edit(trimmed, this.storeName, true);
+        }
+      }
+      return true;
+    } else {
+      this.edit("", void 0, true);
+      this.intro = this.intro.replace(rx, "");
+      if (this.intro.length)
+        return true;
+    }
+  }
+  trimStart(rx) {
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length)
+      return true;
+    const trimmed = this.content.replace(rx, "");
+    if (trimmed.length) {
+      if (trimmed !== this.content) {
+        const newChunk = this.split(this.end - trimmed.length);
+        if (this.edited) {
+          newChunk.edit(trimmed, this.storeName, true);
+        }
+        this.edit("", void 0, true);
+      }
+      return true;
+    } else {
+      this.edit("", void 0, true);
+      this.outro = this.outro.replace(rx, "");
+      if (this.outro.length)
+        return true;
+    }
+  }
+};
+function getBtoa() {
+  if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+    return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+  } else if (typeof Buffer === "function") {
+    return (str) => Buffer.from(str, "utf-8").toString("base64");
+  } else {
+    return () => {
+      throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+    };
+  }
+}
+var btoa = /* @__PURE__ */ getBtoa();
+var SourceMap = class {
+  constructor(properties) {
+    this.version = 3;
+    this.file = properties.file;
+    this.sources = properties.sources;
+    this.sourcesContent = properties.sourcesContent;
+    this.names = properties.names;
+    this.mappings = encode(properties.mappings);
+    if (typeof properties.x_google_ignoreList !== "undefined") {
+      this.x_google_ignoreList = properties.x_google_ignoreList;
+    }
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  toUrl() {
+    return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
+  }
+};
+function guessIndent(code) {
+  const lines = code.split("\n");
+  const tabbed = lines.filter((line) => /^\t+/.test(line));
+  const spaced = lines.filter((line) => /^ {2,}/.test(line));
+  if (tabbed.length === 0 && spaced.length === 0) {
+    return null;
+  }
+  if (tabbed.length >= spaced.length) {
+    return "	";
+  }
+  const min = spaced.reduce((previous, current) => {
+    const numSpaces = /^ +/.exec(current)[0].length;
+    return Math.min(numSpaces, previous);
+  }, Infinity);
+  return new Array(min + 1).join(" ");
+}
+function getRelativePath(from, to) {
+  const fromParts = from.split(/[/\\]/);
+  const toParts = to.split(/[/\\]/);
+  fromParts.pop();
+  while (fromParts[0] === toParts[0]) {
+    fromParts.shift();
+    toParts.shift();
+  }
+  if (fromParts.length) {
+    let i = fromParts.length;
+    while (i--)
+      fromParts[i] = "..";
+  }
+  return fromParts.concat(toParts).join("/");
+}
+var toString = Object.prototype.toString;
+function isObject(thing) {
+  return toString.call(thing) === "[object Object]";
+}
+function getLocator(source) {
+  const originalLines = source.split("\n");
+  const lineOffsets = [];
+  for (let i = 0, pos = 0; i < originalLines.length; i++) {
+    lineOffsets.push(pos);
+    pos += originalLines[i].length + 1;
+  }
+  return function locate(index) {
+    let i = 0;
+    let j = lineOffsets.length;
+    while (i < j) {
+      const m = i + j >> 1;
+      if (index < lineOffsets[m]) {
+        j = m;
+      } else {
+        i = m + 1;
+      }
+    }
+    const line = i - 1;
+    const column = index - lineOffsets[line];
+    return { line, column };
+  };
+}
+var wordRegex = /\w/;
+var Mappings = class {
+  constructor(hires) {
+    this.hires = hires;
+    this.generatedCodeLine = 0;
+    this.generatedCodeColumn = 0;
+    this.raw = [];
+    this.rawSegments = this.raw[this.generatedCodeLine] = [];
+    this.pending = null;
+  }
+  addEdit(sourceIndex, content, loc, nameIndex) {
+    if (content.length) {
+      const contentLengthMinusOne = content.length - 1;
+      let contentLineEnd = content.indexOf("\n", 0);
+      let previousContentLineEnd = -1;
+      while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+        const segment2 = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+        if (nameIndex >= 0) {
+          segment2.push(nameIndex);
+        }
+        this.rawSegments.push(segment2);
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        previousContentLineEnd = contentLineEnd;
+        contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+      }
+      const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+      if (nameIndex >= 0) {
+        segment.push(nameIndex);
+      }
+      this.rawSegments.push(segment);
+      this.advance(content.slice(previousContentLineEnd + 1));
+    } else if (this.pending) {
+      this.rawSegments.push(this.pending);
+      this.advance(content);
+    }
+    this.pending = null;
+  }
+  addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+    let originalCharIndex = chunk.start;
+    let first = true;
+    let charInHiresBoundary = false;
+    while (originalCharIndex < chunk.end) {
+      if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+        const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+        if (this.hires === "boundary") {
+          if (wordRegex.test(original[originalCharIndex])) {
+            if (!charInHiresBoundary) {
+              this.rawSegments.push(segment);
+              charInHiresBoundary = true;
+            }
+          } else {
+            this.rawSegments.push(segment);
+            charInHiresBoundary = false;
+          }
+        } else {
+          this.rawSegments.push(segment);
+        }
+      }
+      if (original[originalCharIndex] === "\n") {
+        loc.line += 1;
+        loc.column = 0;
+        this.generatedCodeLine += 1;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+        this.generatedCodeColumn = 0;
+        first = true;
+      } else {
+        loc.column += 1;
+        this.generatedCodeColumn += 1;
+        first = false;
+      }
+      originalCharIndex += 1;
+    }
+    this.pending = null;
+  }
+  advance(str) {
+    if (!str)
+      return;
+    const lines = str.split("\n");
+    if (lines.length > 1) {
+      for (let i = 0; i < lines.length - 1; i++) {
+        this.generatedCodeLine++;
+        this.raw[this.generatedCodeLine] = this.rawSegments = [];
+      }
+      this.generatedCodeColumn = 0;
+    }
+    this.generatedCodeColumn += lines[lines.length - 1].length;
+  }
+};
+var n = "\n";
+var warned = {
+  insertLeft: false,
+  insertRight: false,
+  storeName: false
+};
+var MagicString = class {
+  constructor(string, options = {}) {
+    const chunk = new Chunk(0, string.length, string);
+    Object.defineProperties(this, {
+      original: { writable: true, value: string },
+      outro: { writable: true, value: "" },
+      intro: { writable: true, value: "" },
+      firstChunk: { writable: true, value: chunk },
+      lastChunk: { writable: true, value: chunk },
+      lastSearchedChunk: { writable: true, value: chunk },
+      byStart: { writable: true, value: {} },
+      byEnd: { writable: true, value: {} },
+      filename: { writable: true, value: options.filename },
+      indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+      sourcemapLocations: { writable: true, value: new BitSet() },
+      storedNames: { writable: true, value: {} },
+      indentStr: { writable: true, value: void 0 },
+      ignoreList: { writable: true, value: options.ignoreList }
+    });
+    this.byStart[0] = chunk;
+    this.byEnd[string.length] = chunk;
+  }
+  addSourcemapLocation(char) {
+    this.sourcemapLocations.add(char);
+  }
+  append(content) {
+    if (typeof content !== "string")
+      throw new TypeError("outro content must be a string");
+    this.outro += content;
+    return this;
+  }
+  appendLeft(index, content) {
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.appendLeft(content);
+    } else {
+      this.intro += content;
+    }
+    return this;
+  }
+  appendRight(index, content) {
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.appendRight(content);
+    } else {
+      this.outro += content;
+    }
+    return this;
+  }
+  clone() {
+    const cloned = new MagicString(this.original, { filename: this.filename });
+    let originalChunk = this.firstChunk;
+    let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+    while (originalChunk) {
+      cloned.byStart[clonedChunk.start] = clonedChunk;
+      cloned.byEnd[clonedChunk.end] = clonedChunk;
+      const nextOriginalChunk = originalChunk.next;
+      const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+      if (nextClonedChunk) {
+        clonedChunk.next = nextClonedChunk;
+        nextClonedChunk.previous = clonedChunk;
+        clonedChunk = nextClonedChunk;
+      }
+      originalChunk = nextOriginalChunk;
+    }
+    cloned.lastChunk = clonedChunk;
+    if (this.indentExclusionRanges) {
+      cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+    }
+    cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+    cloned.intro = this.intro;
+    cloned.outro = this.outro;
+    return cloned;
+  }
+  generateDecodedMap(options) {
+    options = options || {};
+    const sourceIndex = 0;
+    const names = Object.keys(this.storedNames);
+    const mappings = new Mappings(options.hires);
+    const locate = getLocator(this.original);
+    if (this.intro) {
+      mappings.advance(this.intro);
+    }
+    this.firstChunk.eachNext((chunk) => {
+      const loc = locate(chunk.start);
+      if (chunk.intro.length)
+        mappings.advance(chunk.intro);
+      if (chunk.edited) {
+        mappings.addEdit(
+          sourceIndex,
+          chunk.content,
+          loc,
+          chunk.storeName ? names.indexOf(chunk.original) : -1
+        );
+      } else {
+        mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+      }
+      if (chunk.outro.length)
+        mappings.advance(chunk.outro);
+    });
+    return {
+      file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+      sources: [
+        options.source ? getRelativePath(options.file || "", options.source) : options.file || ""
+      ],
+      sourcesContent: options.includeContent ? [this.original] : void 0,
+      names,
+      mappings: mappings.raw,
+      x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
+    };
+  }
+  generateMap(options) {
+    return new SourceMap(this.generateDecodedMap(options));
+  }
+  _ensureindentStr() {
+    if (this.indentStr === void 0) {
+      this.indentStr = guessIndent(this.original);
+    }
+  }
+  _getRawIndentString() {
+    this._ensureindentStr();
+    return this.indentStr;
+  }
+  getIndentString() {
+    this._ensureindentStr();
+    return this.indentStr === null ? "	" : this.indentStr;
+  }
+  indent(indentStr, options) {
+    const pattern = /^[^\r\n]/gm;
+    if (isObject(indentStr)) {
+      options = indentStr;
+      indentStr = void 0;
+    }
+    if (indentStr === void 0) {
+      this._ensureindentStr();
+      indentStr = this.indentStr || "	";
+    }
+    if (indentStr === "")
+      return this;
+    options = options || {};
+    const isExcluded = {};
+    if (options.exclude) {
+      const exclusions = typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude;
+      exclusions.forEach((exclusion) => {
+        for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+          isExcluded[i] = true;
+        }
+      });
+    }
+    let shouldIndentNextCharacter = options.indentStart !== false;
+    const replacer = (match) => {
+      if (shouldIndentNextCharacter)
+        return `${indentStr}${match}`;
+      shouldIndentNextCharacter = true;
+      return match;
+    };
+    this.intro = this.intro.replace(pattern, replacer);
+    let charIndex = 0;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      const end = chunk.end;
+      if (chunk.edited) {
+        if (!isExcluded[charIndex]) {
+          chunk.content = chunk.content.replace(pattern, replacer);
+          if (chunk.content.length) {
+            shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
+          }
+        }
+      } else {
+        charIndex = chunk.start;
+        while (charIndex < end) {
+          if (!isExcluded[charIndex]) {
+            const char = this.original[charIndex];
+            if (char === "\n") {
+              shouldIndentNextCharacter = true;
+            } else if (char !== "\r" && shouldIndentNextCharacter) {
+              shouldIndentNextCharacter = false;
+              if (charIndex === chunk.start) {
+                chunk.prependRight(indentStr);
+              } else {
+                this._splitChunk(chunk, charIndex);
+                chunk = chunk.next;
+                chunk.prependRight(indentStr);
+              }
+            }
+          }
+          charIndex += 1;
+        }
+      }
+      charIndex = chunk.end;
+      chunk = chunk.next;
+    }
+    this.outro = this.outro.replace(pattern, replacer);
+    return this;
+  }
+  insert() {
+    throw new Error(
+      "magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)"
+    );
+  }
+  insertLeft(index, content) {
+    if (!warned.insertLeft) {
+      console.warn(
+        "magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead"
+      );
+      warned.insertLeft = true;
+    }
+    return this.appendLeft(index, content);
+  }
+  insertRight(index, content) {
+    if (!warned.insertRight) {
+      console.warn(
+        "magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead"
+      );
+      warned.insertRight = true;
+    }
+    return this.prependRight(index, content);
+  }
+  move(start, end, index) {
+    if (index >= start && index <= end)
+      throw new Error("Cannot move a selection inside itself");
+    this._split(start);
+    this._split(end);
+    this._split(index);
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    const oldLeft = first.previous;
+    const oldRight = last.next;
+    const newRight = this.byStart[index];
+    if (!newRight && last === this.lastChunk)
+      return this;
+    const newLeft = newRight ? newRight.previous : this.lastChunk;
+    if (oldLeft)
+      oldLeft.next = oldRight;
+    if (oldRight)
+      oldRight.previous = oldLeft;
+    if (newLeft)
+      newLeft.next = first;
+    if (newRight)
+      newRight.previous = last;
+    if (!first.previous)
+      this.firstChunk = last.next;
+    if (!last.next) {
+      this.lastChunk = first.previous;
+      this.lastChunk.next = null;
+    }
+    first.previous = newLeft;
+    last.next = newRight || null;
+    if (!newLeft)
+      this.firstChunk = first;
+    if (!newRight)
+      this.lastChunk = last;
+    return this;
+  }
+  overwrite(start, end, content, options) {
+    options = options || {};
+    return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+  }
+  update(start, end, content, options) {
+    if (typeof content !== "string")
+      throw new TypeError("replacement content must be a string");
+    while (start < 0)
+      start += this.original.length;
+    while (end < 0)
+      end += this.original.length;
+    if (end > this.original.length)
+      throw new Error("end is out of bounds");
+    if (start === end)
+      throw new Error(
+        "Cannot overwrite a zero-length range \u2013 use appendLeft or prependRight instead"
+      );
+    this._split(start);
+    this._split(end);
+    if (options === true) {
+      if (!warned.storeName) {
+        console.warn(
+          "The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string"
+        );
+        warned.storeName = true;
+      }
+      options = { storeName: true };
+    }
+    const storeName = options !== void 0 ? options.storeName : false;
+    const overwrite = options !== void 0 ? options.overwrite : false;
+    if (storeName) {
+      const original = this.original.slice(start, end);
+      Object.defineProperty(this.storedNames, original, {
+        writable: true,
+        value: true,
+        enumerable: true
+      });
+    }
+    const first = this.byStart[start];
+    const last = this.byEnd[end];
+    if (first) {
+      let chunk = first;
+      while (chunk !== last) {
+        if (chunk.next !== this.byStart[chunk.end]) {
+          throw new Error("Cannot overwrite across a split point");
+        }
+        chunk = chunk.next;
+        chunk.edit("", false);
+      }
+      first.edit(content, storeName, !overwrite);
+    } else {
+      const newChunk = new Chunk(start, end, "").edit(content, storeName);
+      last.next = newChunk;
+      newChunk.previous = last;
+    }
+    return this;
+  }
+  prepend(content) {
+    if (typeof content !== "string")
+      throw new TypeError("outro content must be a string");
+    this.intro = content + this.intro;
+    return this;
+  }
+  prependLeft(index, content) {
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byEnd[index];
+    if (chunk) {
+      chunk.prependLeft(content);
+    } else {
+      this.intro = content + this.intro;
+    }
+    return this;
+  }
+  prependRight(index, content) {
+    if (typeof content !== "string")
+      throw new TypeError("inserted content must be a string");
+    this._split(index);
+    const chunk = this.byStart[index];
+    if (chunk) {
+      chunk.prependRight(content);
+    } else {
+      this.outro = content + this.outro;
+    }
+    return this;
+  }
+  remove(start, end) {
+    while (start < 0)
+      start += this.original.length;
+    while (end < 0)
+      end += this.original.length;
+    if (start === end)
+      return this;
+    if (start < 0 || end > this.original.length)
+      throw new Error("Character is out of bounds");
+    if (start > end)
+      throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.intro = "";
+      chunk.outro = "";
+      chunk.edit("");
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  reset(start, end) {
+    while (start < 0)
+      start += this.original.length;
+    while (end < 0)
+      end += this.original.length;
+    if (start === end)
+      return this;
+    if (start < 0 || end > this.original.length)
+      throw new Error("Character is out of bounds");
+    if (start > end)
+      throw new Error("end must be greater than start");
+    this._split(start);
+    this._split(end);
+    let chunk = this.byStart[start];
+    while (chunk) {
+      chunk.reset();
+      chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+    }
+    return this;
+  }
+  lastChar() {
+    if (this.outro.length)
+      return this.outro[this.outro.length - 1];
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length)
+        return chunk.outro[chunk.outro.length - 1];
+      if (chunk.content.length)
+        return chunk.content[chunk.content.length - 1];
+      if (chunk.intro.length)
+        return chunk.intro[chunk.intro.length - 1];
+    } while (chunk = chunk.previous);
+    if (this.intro.length)
+      return this.intro[this.intro.length - 1];
+    return "";
+  }
+  lastLine() {
+    let lineIndex = this.outro.lastIndexOf(n);
+    if (lineIndex !== -1)
+      return this.outro.substr(lineIndex + 1);
+    let lineStr = this.outro;
+    let chunk = this.lastChunk;
+    do {
+      if (chunk.outro.length > 0) {
+        lineIndex = chunk.outro.lastIndexOf(n);
+        if (lineIndex !== -1)
+          return chunk.outro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.outro + lineStr;
+      }
+      if (chunk.content.length > 0) {
+        lineIndex = chunk.content.lastIndexOf(n);
+        if (lineIndex !== -1)
+          return chunk.content.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.content + lineStr;
+      }
+      if (chunk.intro.length > 0) {
+        lineIndex = chunk.intro.lastIndexOf(n);
+        if (lineIndex !== -1)
+          return chunk.intro.substr(lineIndex + 1) + lineStr;
+        lineStr = chunk.intro + lineStr;
+      }
+    } while (chunk = chunk.previous);
+    lineIndex = this.intro.lastIndexOf(n);
+    if (lineIndex !== -1)
+      return this.intro.substr(lineIndex + 1) + lineStr;
+    return this.intro + lineStr;
+  }
+  slice(start = 0, end = this.original.length) {
+    while (start < 0)
+      start += this.original.length;
+    while (end < 0)
+      end += this.original.length;
+    let result = "";
+    let chunk = this.firstChunk;
+    while (chunk && (chunk.start > start || chunk.end <= start)) {
+      if (chunk.start < end && chunk.end >= end) {
+        return result;
+      }
+      chunk = chunk.next;
+    }
+    if (chunk && chunk.edited && chunk.start !== start)
+      throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+    const startChunk = chunk;
+    while (chunk) {
+      if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+        result += chunk.intro;
+      }
+      const containsEnd = chunk.start < end && chunk.end >= end;
+      if (containsEnd && chunk.edited && chunk.end !== end)
+        throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+      const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+      const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+      result += chunk.content.slice(sliceStart, sliceEnd);
+      if (chunk.outro && (!containsEnd || chunk.end === end)) {
+        result += chunk.outro;
+      }
+      if (containsEnd) {
+        break;
+      }
+      chunk = chunk.next;
+    }
+    return result;
+  }
+  snip(start, end) {
+    const clone = this.clone();
+    clone.remove(0, start);
+    clone.remove(end, clone.original.length);
+    return clone;
+  }
+  _split(index) {
+    if (this.byStart[index] || this.byEnd[index])
+      return;
+    let chunk = this.lastSearchedChunk;
+    const searchForward = index > chunk.end;
+    while (chunk) {
+      if (chunk.contains(index))
+        return this._splitChunk(chunk, index);
+      chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+    }
+  }
+  _splitChunk(chunk, index) {
+    if (chunk.edited && chunk.content.length) {
+      const loc = getLocator(this.original)(index);
+      throw new Error(
+        `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} \u2013 "${chunk.original}")`
+      );
+    }
+    const newChunk = chunk.split(index);
+    this.byEnd[index] = chunk;
+    this.byStart[index] = newChunk;
+    this.byEnd[newChunk.end] = newChunk;
+    if (chunk === this.lastChunk)
+      this.lastChunk = newChunk;
+    this.lastSearchedChunk = chunk;
+    return true;
+  }
+  toString() {
+    let str = this.intro;
+    let chunk = this.firstChunk;
+    while (chunk) {
+      str += chunk.toString();
+      chunk = chunk.next;
+    }
+    return str + this.outro;
+  }
+  isEmpty() {
+    let chunk = this.firstChunk;
+    do {
+      if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim())
+        return false;
+    } while (chunk = chunk.next);
+    return true;
+  }
+  length() {
+    let chunk = this.firstChunk;
+    let length = 0;
+    do {
+      length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+    } while (chunk = chunk.next);
+    return length;
+  }
+  trimLines() {
+    return this.trim("[\\r\\n]");
+  }
+  trim(charType) {
+    return this.trimStart(charType).trimEnd(charType);
+  }
+  trimEndAborted(charType) {
+    const rx = new RegExp((charType || "\\s") + "+$");
+    this.outro = this.outro.replace(rx, "");
+    if (this.outro.length)
+      return true;
+    let chunk = this.lastChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimEnd(rx);
+      if (chunk.end !== end) {
+        if (this.lastChunk === chunk) {
+          this.lastChunk = chunk.next;
+        }
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted)
+        return true;
+      chunk = chunk.previous;
+    } while (chunk);
+    return false;
+  }
+  trimEnd(charType) {
+    this.trimEndAborted(charType);
+    return this;
+  }
+  trimStartAborted(charType) {
+    const rx = new RegExp("^" + (charType || "\\s") + "+");
+    this.intro = this.intro.replace(rx, "");
+    if (this.intro.length)
+      return true;
+    let chunk = this.firstChunk;
+    do {
+      const end = chunk.end;
+      const aborted = chunk.trimStart(rx);
+      if (chunk.end !== end) {
+        if (chunk === this.lastChunk)
+          this.lastChunk = chunk.next;
+        this.byEnd[chunk.end] = chunk;
+        this.byStart[chunk.next.start] = chunk.next;
+        this.byEnd[chunk.next.end] = chunk.next;
+      }
+      if (aborted)
+        return true;
+      chunk = chunk.next;
+    } while (chunk);
+    return false;
+  }
+  trimStart(charType) {
+    this.trimStartAborted(charType);
+    return this;
+  }
+  hasChanged() {
+    return this.original !== this.toString();
+  }
+  _replaceRegexp(searchValue, replacement) {
+    function getReplacement(match, str) {
+      if (typeof replacement === "string") {
+        return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+          if (i === "$")
+            return "$";
+          if (i === "&")
+            return match[0];
+          const num = +i;
+          if (num < match.length)
+            return match[+i];
+          return `$${i}`;
+        });
+      } else {
+        return replacement(...match, match.index, str, match.groups);
+      }
+    }
+    function matchAll(re, str) {
+      let match;
+      const matches = [];
+      while (match = re.exec(str)) {
+        matches.push(match);
+      }
+      return matches;
+    }
+    if (searchValue.global) {
+      const matches = matchAll(searchValue, this.original);
+      matches.forEach((match) => {
+        if (match.index != null)
+          this.overwrite(
+            match.index,
+            match.index + match[0].length,
+            getReplacement(match, this.original)
+          );
+      });
+    } else {
+      const match = this.original.match(searchValue);
+      if (match && match.index != null)
+        this.overwrite(
+          match.index,
+          match.index + match[0].length,
+          getReplacement(match, this.original)
+        );
+    }
+    return this;
+  }
+  _replaceString(string, replacement) {
+    const { original } = this;
+    const index = original.indexOf(string);
+    if (index !== -1) {
+      this.overwrite(index, index + string.length, replacement);
+    }
+    return this;
+  }
+  replace(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceString(searchValue, replacement);
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+  _replaceAllString(string, replacement) {
+    const { original } = this;
+    const stringLength = string.length;
+    for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+      this.overwrite(index, index + stringLength, replacement);
+    }
+    return this;
+  }
+  replaceAll(searchValue, replacement) {
+    if (typeof searchValue === "string") {
+      return this._replaceAllString(searchValue, replacement);
+    }
+    if (!searchValue.global) {
+      throw new TypeError(
+        "MagicString.prototype.replaceAll called with a non-global RegExp argument"
+      );
+    }
+    return this._replaceRegexp(searchValue, replacement);
+  }
+};
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/context.mjs
-import ts31 from "typescript";
+import ts32 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/dom.mjs
 import { DomElementSchemaRegistry } from "@angular/compiler";
-import ts19 from "typescript";
+import ts20 from "typescript";
 var REGISTRY = new DomElementSchemaRegistry();
 var REMOVE_XHTML_REGEX = /^:xhtml:/;
 var RegistryDomSchemaChecker = class {
@@ -3027,7 +4186,7 @@ var RegistryDomSchemaChecker = class {
       } else {
         errorMsg += `2. To allow any element add 'NO_ERRORS_SCHEMA' to the ${schemas2} of this component.`;
       }
-      const diag = makeTemplateDiagnostic(id, mapping, element.startSourceSpan, ts19.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ELEMENT), errorMsg);
+      const diag = makeTemplateDiagnostic(id, mapping, element.startSourceSpan, ts20.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ELEMENT), errorMsg);
       this._diagnostics.push(diag);
     }
   }
@@ -3047,14 +4206,14 @@ var RegistryDomSchemaChecker = class {
 2. If '${element.name}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the ${schemas2} of this component to suppress this message.
 3. To allow any property add 'NO_ERRORS_SCHEMA' to the ${schemas2} of this component.`;
       }
-      const diag = makeTemplateDiagnostic(id, mapping, span, ts19.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ATTRIBUTE), errorMsg);
+      const diag = makeTemplateDiagnostic(id, mapping, span, ts20.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ATTRIBUTE), errorMsg);
       this._diagnostics.push(diag);
     }
   }
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/environment.mjs
-import ts24 from "typescript";
+import ts25 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/reference_emit_environment.mjs
 import { ExpressionType, ExternalExpr, TypeModifier } from "@angular/compiler";
@@ -3076,7 +4235,7 @@ var ReferenceEmitEnvironment = class {
   }
   referenceExternalSymbol(moduleName, name) {
     const external = new ExternalExpr({ moduleName, name });
-    return translateExpression(external, this.importManager);
+    return translateExpression(this.contextFile, external, this.importManager);
   }
   referenceExternalType(moduleName, name, typeParams) {
     const external = new ExternalExpr({ moduleName, name });
@@ -3088,105 +4247,98 @@ var ReferenceEmitEnvironment = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/ts_util.mjs
-import ts20 from "typescript";
+import ts21 from "typescript";
 var SAFE_TO_CAST_WITHOUT_PARENS = /* @__PURE__ */ new Set([
-  ts20.SyntaxKind.ParenthesizedExpression,
-  ts20.SyntaxKind.Identifier,
-  ts20.SyntaxKind.CallExpression,
-  ts20.SyntaxKind.NonNullExpression,
-  ts20.SyntaxKind.ElementAccessExpression,
-  ts20.SyntaxKind.PropertyAccessExpression,
-  ts20.SyntaxKind.ArrayLiteralExpression,
-  ts20.SyntaxKind.ObjectLiteralExpression,
-  ts20.SyntaxKind.StringLiteral,
-  ts20.SyntaxKind.NumericLiteral,
-  ts20.SyntaxKind.TrueKeyword,
-  ts20.SyntaxKind.FalseKeyword,
-  ts20.SyntaxKind.NullKeyword,
-  ts20.SyntaxKind.UndefinedKeyword
+  ts21.SyntaxKind.ParenthesizedExpression,
+  ts21.SyntaxKind.Identifier,
+  ts21.SyntaxKind.CallExpression,
+  ts21.SyntaxKind.NonNullExpression,
+  ts21.SyntaxKind.ElementAccessExpression,
+  ts21.SyntaxKind.PropertyAccessExpression,
+  ts21.SyntaxKind.ArrayLiteralExpression,
+  ts21.SyntaxKind.ObjectLiteralExpression,
+  ts21.SyntaxKind.StringLiteral,
+  ts21.SyntaxKind.NumericLiteral,
+  ts21.SyntaxKind.TrueKeyword,
+  ts21.SyntaxKind.FalseKeyword,
+  ts21.SyntaxKind.NullKeyword,
+  ts21.SyntaxKind.UndefinedKeyword
 ]);
 function tsCastToAny(expr) {
   if (!SAFE_TO_CAST_WITHOUT_PARENS.has(expr.kind)) {
-    expr = ts20.factory.createParenthesizedExpression(expr);
+    expr = ts21.factory.createParenthesizedExpression(expr);
   }
-  return ts20.factory.createParenthesizedExpression(ts20.factory.createAsExpression(expr, ts20.factory.createKeywordTypeNode(ts20.SyntaxKind.AnyKeyword)));
+  return ts21.factory.createParenthesizedExpression(ts21.factory.createAsExpression(expr, ts21.factory.createKeywordTypeNode(ts21.SyntaxKind.AnyKeyword)));
 }
 function tsCreateElement(tagName) {
-  const createElement = ts20.factory.createPropertyAccessExpression(
-    ts20.factory.createIdentifier("document"),
+  const createElement = ts21.factory.createPropertyAccessExpression(
+    ts21.factory.createIdentifier("document"),
     "createElement"
   );
-  return ts20.factory.createCallExpression(
+  return ts21.factory.createCallExpression(
     createElement,
     void 0,
-    [ts20.factory.createStringLiteral(tagName)]
+    [ts21.factory.createStringLiteral(tagName)]
   );
 }
 function tsDeclareVariable(id, type) {
   addExpressionIdentifier(type, ExpressionIdentifier.VARIABLE_AS_EXPRESSION);
-  const initializer = ts20.factory.createAsExpression(ts20.factory.createNonNullExpression(ts20.factory.createNull()), type);
-  const decl = ts20.factory.createVariableDeclaration(
+  const initializer = ts21.factory.createAsExpression(ts21.factory.createNonNullExpression(ts21.factory.createNull()), type);
+  const decl = ts21.factory.createVariableDeclaration(
     id,
     void 0,
     void 0,
     initializer
   );
-  return ts20.factory.createVariableStatement(
+  return ts21.factory.createVariableStatement(
     void 0,
     [decl]
   );
 }
 function tsCreateTypeQueryForCoercedInput(typeName, coercedInputName) {
-  return ts20.factory.createTypeQueryNode(ts20.factory.createQualifiedName(typeName, `ngAcceptInputType_${coercedInputName}`));
+  return ts21.factory.createTypeQueryNode(ts21.factory.createQualifiedName(typeName, `ngAcceptInputType_${coercedInputName}`));
 }
 function tsCreateVariable(id, initializer) {
-  const decl = ts20.factory.createVariableDeclaration(
+  const decl = ts21.factory.createVariableDeclaration(
     id,
     void 0,
     void 0,
     initializer
   );
-  return ts20.factory.createVariableStatement(
+  return ts21.factory.createVariableStatement(
     void 0,
     [decl]
   );
 }
 function tsCallMethod(receiver, methodName, args = []) {
-  const methodAccess = ts20.factory.createPropertyAccessExpression(receiver, methodName);
-  return ts20.factory.createCallExpression(
+  const methodAccess = ts21.factory.createPropertyAccessExpression(receiver, methodName);
+  return ts21.factory.createCallExpression(
     methodAccess,
     void 0,
     args
   );
 }
 function isAccessExpression(node) {
-  return ts20.isPropertyAccessExpression(node) || ts20.isElementAccessExpression(node);
+  return ts21.isPropertyAccessExpression(node) || ts21.isElementAccessExpression(node);
 }
 function tsNumericExpression(value) {
   if (value < 0) {
-    const operand = ts20.factory.createNumericLiteral(Math.abs(value));
-    return ts20.factory.createPrefixUnaryExpression(ts20.SyntaxKind.MinusToken, operand);
-  }
-  return ts20.factory.createNumericLiteral(value);
-}
-function getImportString(imp) {
-  if (imp.qualifier === null) {
-    return `import from '${imp.specifier}';`;
-  } else {
-    return `import * as ${imp.qualifier.text} from '${imp.specifier}';`;
+    const operand = ts21.factory.createNumericLiteral(Math.abs(value));
+    return ts21.factory.createPrefixUnaryExpression(ts21.SyntaxKind.MinusToken, operand);
   }
+  return ts21.factory.createNumericLiteral(value);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.mjs
 import { ExpressionType as ExpressionType2, R3Identifiers as R3Identifiers2, WrappedNodeExpr } from "@angular/compiler";
-import ts23 from "typescript";
+import ts24 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.mjs
 import { R3Identifiers } from "@angular/compiler";
-import ts22 from "typescript";
+import ts23 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.mjs
-import ts21 from "typescript";
+import ts22 from "typescript";
 var TypeParameterEmitter = class {
   constructor(typeParameters, reflector) {
     this.typeParameters = typeParameters;
@@ -3223,11 +4375,11 @@ var TypeParameterEmitter = class {
     return this.typeParameters.map((typeParam) => {
       const constraint = typeParam.constraint !== void 0 ? emitter.emitType(typeParam.constraint) : void 0;
       const defaultType = typeParam.default !== void 0 ? emitter.emitType(typeParam.default) : void 0;
-      return ts21.factory.updateTypeParameterDeclaration(typeParam, typeParam.modifiers, typeParam.name, constraint, defaultType);
+      return ts22.factory.updateTypeParameterDeclaration(typeParam, typeParam.modifiers, typeParam.name, constraint, defaultType);
     });
   }
   resolveTypeReference(type) {
-    const target = ts21.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
+    const target = ts22.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
     const declaration = this.reflector.getDeclarationOfIdentifier(target);
     if (declaration === null || declaration.node === null) {
       return null;
@@ -3253,8 +4405,8 @@ var TypeParameterEmitter = class {
     if (typeNode === null) {
       return null;
     }
-    if (!ts21.isTypeReferenceNode(typeNode)) {
-      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts21.SyntaxKind[typeNode.kind]}.`);
+    if (!ts22.isTypeReferenceNode(typeNode)) {
+      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts22.SyntaxKind[typeNode.kind]}.`);
     }
     return typeNode;
   }
@@ -3264,8 +4416,8 @@ var TypeParameterEmitter = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.mjs
-var TCB_FILE_IMPORT_GRAPH_PREPARE_MODULES = [
-  R3Identifiers.InputSignalBrandWriteType.moduleName
+var TCB_FILE_IMPORT_GRAPH_PREPARE_IDENTIFIERS = [
+  R3Identifiers.InputSignalBrandWriteType
 ];
 var TcbInliningRequirement;
 (function(TcbInliningRequirement2) {
@@ -3299,14 +4451,14 @@ function getTemplateMapping(shimSf, position, resolver, isDiagnosticRequest) {
 }
 function findTypeCheckBlock(file, id, isDiagnosticRequest) {
   for (const stmt of file.statements) {
-    if (ts22.isFunctionDeclaration(stmt) && getTemplateId2(stmt, file, isDiagnosticRequest) === id) {
+    if (ts23.isFunctionDeclaration(stmt) && getTemplateId2(stmt, file, isDiagnosticRequest) === id) {
       return stmt;
     }
   }
   return null;
 }
 function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
-  while (node !== void 0 && !ts22.isFunctionDeclaration(node)) {
+  while (node !== void 0 && !ts23.isFunctionDeclaration(node)) {
     if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {
       return null;
     }
@@ -3323,7 +4475,7 @@ function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
   return null;
 }
 function getTemplateId2(node, sourceFile, isDiagnosticRequest) {
-  while (!ts22.isFunctionDeclaration(node)) {
+  while (!ts23.isFunctionDeclaration(node)) {
     if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {
       return null;
     }
@@ -3333,8 +4485,8 @@ function getTemplateId2(node, sourceFile, isDiagnosticRequest) {
     }
   }
   const start = node.getFullStart();
-  return ts22.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
-    if (kind !== ts22.SyntaxKind.MultiLineCommentTrivia) {
+  return ts23.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
+    if (kind !== ts23.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -3342,8 +4494,12 @@ function getTemplateId2(node, sourceFile, isDiagnosticRequest) {
   }) || null;
 }
 function ensureTypeCheckFilePreparationImports(env) {
-  for (const moduleName of TCB_FILE_IMPORT_GRAPH_PREPARE_MODULES) {
-    env.importManager.generateNamespaceImport(moduleName);
+  for (const identifier of TCB_FILE_IMPORT_GRAPH_PREPARE_IDENTIFIERS) {
+    env.importManager.addImport({
+      exportModuleSpecifier: identifier.moduleName,
+      exportSymbolName: identifier.name,
+      requestedFile: env.contextFile
+    });
   }
 }
 function checkIfGenericTypeBoundsCanBeEmitted(node, reflector, env) {
@@ -3354,29 +4510,29 @@ function checkIfGenericTypeBoundsCanBeEmitted(node, reflector, env) {
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.mjs
 function generateTypeCtorDeclarationFn(env, meta, nodeTypeRef, typeParams) {
   const rawTypeArgs = typeParams !== void 0 ? generateGenericArgs(typeParams) : void 0;
-  const rawType = ts23.factory.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);
+  const rawType = ts24.factory.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);
   const initParam = constructTypeCtorParameter(env, meta, rawType);
   const typeParameters = typeParametersWithDefaultTypes(typeParams);
   if (meta.body) {
-    const fnType = ts23.factory.createFunctionTypeNode(
+    const fnType = ts24.factory.createFunctionTypeNode(
       typeParameters,
       [initParam],
       rawType
     );
-    const decl = ts23.factory.createVariableDeclaration(
+    const decl = ts24.factory.createVariableDeclaration(
       meta.fnName,
       void 0,
       fnType,
-      ts23.factory.createNonNullExpression(ts23.factory.createNull())
+      ts24.factory.createNonNullExpression(ts24.factory.createNull())
     );
-    const declList = ts23.factory.createVariableDeclarationList([decl], ts23.NodeFlags.Const);
-    return ts23.factory.createVariableStatement(
+    const declList = ts24.factory.createVariableDeclarationList([decl], ts24.NodeFlags.Const);
+    return ts24.factory.createVariableStatement(
       void 0,
       declList
     );
   } else {
-    return ts23.factory.createFunctionDeclaration(
-      [ts23.factory.createModifier(ts23.SyntaxKind.DeclareKeyword)],
+    return ts24.factory.createFunctionDeclaration(
+      [ts24.factory.createModifier(ts24.SyntaxKind.DeclareKeyword)],
       void 0,
       meta.fnName,
       typeParameters,
@@ -3388,16 +4544,16 @@ function generateTypeCtorDeclarationFn(env, meta, nodeTypeRef, typeParams) {
 }
 function generateInlineTypeCtor(env, node, meta) {
   const rawTypeArgs = node.typeParameters !== void 0 ? generateGenericArgs(node.typeParameters) : void 0;
-  const rawType = ts23.factory.createTypeReferenceNode(node.name, rawTypeArgs);
+  const rawType = ts24.factory.createTypeReferenceNode(node.name, rawTypeArgs);
   const initParam = constructTypeCtorParameter(env, meta, rawType);
   let body = void 0;
   if (meta.body) {
-    body = ts23.factory.createBlock([
-      ts23.factory.createReturnStatement(ts23.factory.createNonNullExpression(ts23.factory.createNull()))
+    body = ts24.factory.createBlock([
+      ts24.factory.createReturnStatement(ts24.factory.createNonNullExpression(ts24.factory.createNull()))
     ]);
   }
-  return ts23.factory.createMethodDeclaration(
-    [ts23.factory.createModifier(ts23.SyntaxKind.StaticKeyword)],
+  return ts24.factory.createMethodDeclaration(
+    [ts24.factory.createModifier(ts24.SyntaxKind.StaticKeyword)],
     void 0,
     meta.fnName,
     void 0,
@@ -3414,12 +4570,12 @@ function constructTypeCtorParameter(env, meta, rawType) {
   const signalInputKeys = [];
   for (const { classPropertyName, transform, isSignal } of meta.fields.inputs) {
     if (isSignal) {
-      signalInputKeys.push(ts23.factory.createLiteralTypeNode(ts23.factory.createStringLiteral(classPropertyName)));
+      signalInputKeys.push(ts24.factory.createLiteralTypeNode(ts24.factory.createStringLiteral(classPropertyName)));
     } else if (!meta.coercedInputFields.has(classPropertyName)) {
-      plainKeys.push(ts23.factory.createLiteralTypeNode(ts23.factory.createStringLiteral(classPropertyName)));
+      plainKeys.push(ts24.factory.createLiteralTypeNode(ts24.factory.createStringLiteral(classPropertyName)));
     } else {
       const coercionType = transform != null ? transform.type.node : tsCreateTypeQueryForCoercedInput(rawType.typeName, classPropertyName);
-      coercedKeys.push(ts23.factory.createPropertySignature(
+      coercedKeys.push(ts24.factory.createPropertySignature(
         void 0,
         classPropertyName,
         void 0,
@@ -3428,25 +4584,25 @@ function constructTypeCtorParameter(env, meta, rawType) {
     }
   }
   if (plainKeys.length > 0) {
-    const keyTypeUnion = ts23.factory.createUnionTypeNode(plainKeys);
-    initType = ts23.factory.createTypeReferenceNode("Pick", [rawType, keyTypeUnion]);
+    const keyTypeUnion = ts24.factory.createUnionTypeNode(plainKeys);
+    initType = ts24.factory.createTypeReferenceNode("Pick", [rawType, keyTypeUnion]);
   }
   if (coercedKeys.length > 0) {
-    const coercedLiteral = ts23.factory.createTypeLiteralNode(coercedKeys);
-    initType = initType !== null ? ts23.factory.createIntersectionTypeNode([initType, coercedLiteral]) : coercedLiteral;
+    const coercedLiteral = ts24.factory.createTypeLiteralNode(coercedKeys);
+    initType = initType !== null ? ts24.factory.createIntersectionTypeNode([initType, coercedLiteral]) : coercedLiteral;
   }
   if (signalInputKeys.length > 0) {
-    const keyTypeUnion = ts23.factory.createUnionTypeNode(signalInputKeys);
+    const keyTypeUnion = ts24.factory.createUnionTypeNode(signalInputKeys);
     const unwrapDirectiveSignalInputsExpr = env.referenceExternalType(R3Identifiers2.UnwrapDirectiveSignalInputs.moduleName, R3Identifiers2.UnwrapDirectiveSignalInputs.name, [
       new ExpressionType2(new WrappedNodeExpr(rawType)),
       new ExpressionType2(new WrappedNodeExpr(keyTypeUnion))
     ]);
-    initType = initType !== null ? ts23.factory.createIntersectionTypeNode([initType, unwrapDirectiveSignalInputsExpr]) : unwrapDirectiveSignalInputsExpr;
+    initType = initType !== null ? ts24.factory.createIntersectionTypeNode([initType, unwrapDirectiveSignalInputsExpr]) : unwrapDirectiveSignalInputsExpr;
   }
   if (initType === null) {
-    initType = ts23.factory.createTypeLiteralNode([]);
+    initType = ts24.factory.createTypeLiteralNode([]);
   }
-  return ts23.factory.createParameterDeclaration(
+  return ts24.factory.createParameterDeclaration(
     void 0,
     void 0,
     "init",
@@ -3456,7 +4612,7 @@ function constructTypeCtorParameter(env, meta, rawType) {
   );
 }
 function generateGenericArgs(params) {
-  return params.map((param) => ts23.factory.createTypeReferenceNode(param.name, void 0));
+  return params.map((param) => ts24.factory.createTypeReferenceNode(param.name, void 0));
 }
 function requiresInlineTypeCtor(node, host, env) {
   return !checkIfGenericTypeBoundsCanBeEmitted(node, host, env);
@@ -3467,7 +4623,7 @@ function typeParametersWithDefaultTypes(params) {
   }
   return params.map((param) => {
     if (param.default === void 0) {
-      return ts23.factory.updateTypeParameterDeclaration(param, param.modifiers, param.name, param.constraint, ts23.factory.createKeywordTypeNode(ts23.SyntaxKind.AnyKeyword));
+      return ts24.factory.updateTypeParameterDeclaration(param, param.modifiers, param.name, param.constraint, ts24.factory.createKeywordTypeNode(ts24.SyntaxKind.AnyKeyword));
     } else {
       return param;
     }
@@ -3496,13 +4652,13 @@ var Environment = class extends ReferenceEmitEnvironment {
     }
     if (requiresInlineTypeCtor(node, this.reflector, this)) {
       const ref = this.reference(dirRef);
-      const typeCtorExpr = ts24.factory.createPropertyAccessExpression(ref, "ngTypeCtor");
+      const typeCtorExpr = ts25.factory.createPropertyAccessExpression(ref, "ngTypeCtor");
       this.typeCtors.set(node, typeCtorExpr);
       return typeCtorExpr;
     } else {
       const fnName = `_ctor${this.nextIds.typeCtor++}`;
       const nodeTypeRef = this.referenceType(dirRef);
-      if (!ts24.isTypeReferenceNode(nodeTypeRef)) {
+      if (!ts25.isTypeReferenceNode(nodeTypeRef)) {
         throw new Error(`Expected TypeReferenceNode from reference to ${dirRef.debugName}`);
       }
       const meta = {
@@ -3517,7 +4673,7 @@ var Environment = class extends ReferenceEmitEnvironment {
       const typeParams = this.emitTypeParameters(node);
       const typeCtor = generateTypeCtorDeclarationFn(this, meta, nodeTypeRef.typeName, typeParams);
       this.typeCtorStatements.push(typeCtor);
-      const fnId = ts24.factory.createIdentifier(fnName);
+      const fnId = ts25.factory.createIdentifier(fnName);
       this.typeCtors.set(node, fnId);
       return fnId;
     }
@@ -3527,7 +4683,7 @@ var Environment = class extends ReferenceEmitEnvironment {
       return this.pipeInsts.get(ref.node);
     }
     const pipeType = this.referenceType(ref);
-    const pipeInstId = ts24.factory.createIdentifier(`_pipe${this.nextIds.pipeInst++}`);
+    const pipeInstId = ts25.factory.createIdentifier(`_pipe${this.nextIds.pipeInst++}`);
     this.pipeInstStatements.push(tsDeclareVariable(pipeInstId, pipeType));
     this.pipeInsts.set(ref.node, pipeInstId);
     return pipeInstId;
@@ -3535,7 +4691,7 @@ var Environment = class extends ReferenceEmitEnvironment {
   reference(ref) {
     const ngExpr = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing);
     assertSuccessfulReferenceEmit(ngExpr, this.contextFile, "class");
-    return translateExpression(ngExpr.expression, this.importManager);
+    return translateExpression(this.contextFile, ngExpr.expression, this.importManager);
   }
   emitTypeParameters(declaration) {
     const emitter = new TypeParameterEmitter(declaration.typeParameters, this.reflector);
@@ -3551,7 +4707,7 @@ var Environment = class extends ReferenceEmitEnvironment {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/oob.mjs
 import { AbsoluteSourceSpan as AbsoluteSourceSpan3, TmplAstElement as TmplAstElement2, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty } from "@angular/compiler";
-import ts25 from "typescript";
+import ts26 from "typescript";
 var OutOfBandDiagnosticRecorderImpl = class {
   constructor(resolver) {
     this.resolver = resolver;
@@ -3565,7 +4721,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     const mapping = this.resolver.getSourceMapping(templateId);
     const value = ref.value.trim();
     const errorMsg = `No directive found with exportAs '${value}'.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, ref.valueSpan || ref.sourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_REFERENCE_TARGET), errorMsg));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, ref.valueSpan || ref.sourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_REFERENCE_TARGET), errorMsg));
   }
   missingPipe(templateId, ast) {
     if (this.recordedPipes.has(ast)) {
@@ -3577,7 +4733,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     if (sourceSpan === null) {
       throw new Error(`Assertion failure: no SourceLocation found for usage of pipe '${ast.name}'.`);
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_PIPE), errorMsg));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_PIPE), errorMsg));
     this.recordedPipes.add(ast);
   }
   deferredPipeUsedEagerly(templateId, ast) {
@@ -3590,7 +4746,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     if (sourceSpan === null) {
       throw new Error(`Assertion failure: no SourceLocation found for usage of pipe '${ast.name}'.`);
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DEFERRED_PIPE_USED_EAGERLY), errorMsg));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DEFERRED_PIPE_USED_EAGERLY), errorMsg));
     this.recordedPipes.add(ast);
   }
   deferredComponentUsedEagerly(templateId, element) {
@@ -3602,12 +4758,12 @@ var OutOfBandDiagnosticRecorderImpl = class {
     if (sourceSpan === null) {
       throw new Error(`Assertion failure: no SourceLocation found for usage of pipe '${element.name}'.`);
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DEFERRED_DIRECTIVE_USED_EAGERLY), errorMsg));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DEFERRED_DIRECTIVE_USED_EAGERLY), errorMsg));
   }
   duplicateTemplateVar(templateId, variable, firstDecl) {
     const mapping = this.resolver.getSourceMapping(templateId);
     const errorMsg = `Cannot redeclare variable '${variable.name}' as it was previously declared elsewhere for the same template.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, variable.sourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DUPLICATE_VARIABLE_DECLARATION), errorMsg, [{
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, variable.sourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DUPLICATE_VARIABLE_DECLARATION), errorMsg, [{
       text: `The variable '${firstDecl.name}' was first declared here.`,
       start: firstDecl.sourceSpan.start.offset,
       end: firstDecl.sourceSpan.end.offset,
@@ -3646,7 +4802,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     const message = `This structural directive supports advanced type inference, but the current compiler configuration prevents its usage. The variable ${varIdentification} will have type 'any' as a result.
 
 Consider enabling the 'strictTemplates' option in your tsconfig.json for better type inference within this template.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, diagnosticVar.keySpan, ts25.DiagnosticCategory.Suggestion, ngErrorCode(ErrorCode.SUGGEST_SUBOPTIMAL_TYPE_INFERENCE), message));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, diagnosticVar.keySpan, ts26.DiagnosticCategory.Suggestion, ngErrorCode(ErrorCode.SUGGEST_SUBOPTIMAL_TYPE_INFERENCE), message));
   }
   splitTwoWayBinding(templateId, input, output, inputConsumer, outputConsumer) {
     const mapping = this.resolver.getSourceMapping(templateId);
@@ -3680,11 +4836,11 @@ Consider enabling the 'strictTemplates' option in your tsconfig.json for better
         sourceFile: outputConsumer.name.getSourceFile()
       });
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, input.keySpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SPLIT_TWO_WAY_BINDING), errorMsg, relatedMessages));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, input.keySpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SPLIT_TWO_WAY_BINDING), errorMsg, relatedMessages));
   }
   missingRequiredInputs(templateId, element, directiveName, isComponent, inputAliases) {
-    const message = `Required input${inputAliases.length === 1 ? "" : "s"} ${inputAliases.map((n) => `'${n}'`).join(", ")} from ${isComponent ? "component" : "directive"} ${directiveName} must be specified.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), element.startSourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_REQUIRED_INPUTS), message));
+    const message = `Required input${inputAliases.length === 1 ? "" : "s"} ${inputAliases.map((n2) => `'${n2}'`).join(", ")} from ${isComponent ? "component" : "directive"} ${directiveName} must be specified.`;
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), element.startSourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_REQUIRED_INPUTS), message));
   }
   illegalForLoopTrackAccess(templateId, block, access) {
     const sourceSpan = this.resolver.toParseSourceSpan(templateId, access.sourceSpan);
@@ -3692,7 +4848,7 @@ Consider enabling the 'strictTemplates' option in your tsconfig.json for better
       throw new Error(`Assertion failure: no SourceLocation found for property read.`);
     }
     const message = `Cannot access '${access.name}' inside of a track expression. Only '${block.item.name}', '${block.contextVariables.$index.name}' and properties on the containing component are available to this expression.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), sourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.ILLEGAL_FOR_LOOP_TRACK_ACCESS), message));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), sourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.ILLEGAL_FOR_LOOP_TRACK_ACCESS), message));
   }
   inaccessibleDeferredTriggerElement(templateId, trigger) {
     let message;
@@ -3703,7 +4859,7 @@ Consider enabling the 'strictTemplates' option in your tsconfig.json for better
 Check that an element with #${trigger.reference} exists in the same template and it's accessible from the @defer block.
 Deferred blocks can only access triggers in same view, a parent embedded view or the root view of the @placeholder block.`;
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), trigger.sourceSpan, ts25.DiagnosticCategory.Error, ngErrorCode(ErrorCode.INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT), message));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), trigger.sourceSpan, ts26.DiagnosticCategory.Error, ngErrorCode(ErrorCode.INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT), message));
   }
   controlFlowPreventingContentProjection(templateId, category, projectionNode, componentName, slotSelector, controlFlowNode, preservesWhitespaces) {
     let blockName;
@@ -3737,7 +4893,7 @@ function makeInlineDiagnostic(templateId, code, node, messageText, relatedInform
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/shim.mjs
-import ts26 from "typescript";
+import ts27 from "typescript";
 var TypeCheckShimGenerator = class {
   constructor() {
     this.extensionPrefix = "ngtypecheck";
@@ -3747,7 +4903,7 @@ var TypeCheckShimGenerator = class {
     if (priorShimSf !== null) {
       return priorShimSf;
     }
-    return ts26.createSourceFile(genFilePath, "export const USED_FOR_NG_TYPE_CHECKING = true;", ts26.ScriptTarget.Latest, true, ts26.ScriptKind.TS);
+    return ts27.createSourceFile(genFilePath, "export const USED_FOR_NG_TYPE_CHECKING = true;", ts27.ScriptTarget.Latest, true, ts27.ScriptKind.TS);
   }
   static shimFor(fileName) {
     return absoluteFrom(fileName.replace(/\.tsx?$/, ".ngtypecheck.ts"));
@@ -3756,16 +4912,16 @@ var TypeCheckShimGenerator = class {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_check_block.mjs
 import { BindingPipe, Call as Call2, createCssSelectorFromNode, CssSelector, DYNAMIC_TYPE, ImplicitReceiver as ImplicitReceiver3, PropertyRead as PropertyRead4, PropertyWrite as PropertyWrite3, R3Identifiers as R3Identifiers3, SafeCall, SafePropertyRead as SafePropertyRead3, SelectorMatcher, ThisReceiver, TmplAstBoundAttribute, TmplAstBoundText, TmplAstDeferredBlock, TmplAstElement as TmplAstElement3, TmplAstForLoopBlock as TmplAstForLoopBlock2, TmplAstIcu, TmplAstIfBlock, TmplAstIfBlockBranch, TmplAstReference as TmplAstReference3, TmplAstSwitchBlock, TmplAstTemplate as TmplAstTemplate2, TmplAstText, TmplAstTextAttribute as TmplAstTextAttribute2, TmplAstVariable, TransplantedType } from "@angular/compiler";
-import ts29 from "typescript";
+import ts30 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/diagnostics.mjs
 import { AbsoluteSourceSpan as AbsoluteSourceSpan4 } from "@angular/compiler";
-import ts27 from "typescript";
+import ts28 from "typescript";
 function wrapForDiagnostics(expr) {
-  return ts27.factory.createParenthesizedExpression(expr);
+  return ts28.factory.createParenthesizedExpression(expr);
 }
 function wrapForTypeChecker(expr) {
-  return ts27.factory.createParenthesizedExpression(expr);
+  return ts28.factory.createParenthesizedExpression(expr);
 }
 function addParseSpanInfo(node, span) {
   let commentText;
@@ -3774,10 +4930,10 @@ function addParseSpanInfo(node, span) {
   } else {
     commentText = `${span.start.offset},${span.end.offset}`;
   }
-  ts27.addSyntheticTrailingComment(node, ts27.SyntaxKind.MultiLineCommentTrivia, commentText, false);
+  ts28.addSyntheticTrailingComment(node, ts28.SyntaxKind.MultiLineCommentTrivia, commentText, false);
 }
 function addTemplateId(tcb, id) {
-  ts27.addSyntheticLeadingComment(tcb, ts27.SyntaxKind.MultiLineCommentTrivia, id, true);
+  ts28.addSyntheticLeadingComment(tcb, ts28.SyntaxKind.MultiLineCommentTrivia, id, true);
 }
 function shouldReportDiagnostic(diagnostic) {
   const { code } = diagnostic;
@@ -3806,32 +4962,32 @@ function translateDiagnostic(diagnostic, resolver) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/expression.mjs
 import { ASTWithSource as ASTWithSource2, Call, EmptyExpr as EmptyExpr2, PropertyRead as PropertyRead3, SafeKeyedRead, SafePropertyRead as SafePropertyRead2 } from "@angular/compiler";
-import ts28 from "typescript";
-var NULL_AS_ANY = ts28.factory.createAsExpression(ts28.factory.createNull(), ts28.factory.createKeywordTypeNode(ts28.SyntaxKind.AnyKeyword));
-var UNDEFINED = ts28.factory.createIdentifier("undefined");
+import ts29 from "typescript";
+var NULL_AS_ANY = ts29.factory.createAsExpression(ts29.factory.createNull(), ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword));
+var UNDEFINED = ts29.factory.createIdentifier("undefined");
 var UNARY_OPS = /* @__PURE__ */ new Map([
-  ["+", ts28.SyntaxKind.PlusToken],
-  ["-", ts28.SyntaxKind.MinusToken]
+  ["+", ts29.SyntaxKind.PlusToken],
+  ["-", ts29.SyntaxKind.MinusToken]
 ]);
 var BINARY_OPS = /* @__PURE__ */ new Map([
-  ["+", ts28.SyntaxKind.PlusToken],
-  ["-", ts28.SyntaxKind.MinusToken],
-  ["<", ts28.SyntaxKind.LessThanToken],
-  [">", ts28.SyntaxKind.GreaterThanToken],
-  ["<=", ts28.SyntaxKind.LessThanEqualsToken],
-  [">=", ts28.SyntaxKind.GreaterThanEqualsToken],
-  ["==", ts28.SyntaxKind.EqualsEqualsToken],
-  ["===", ts28.SyntaxKind.EqualsEqualsEqualsToken],
-  ["*", ts28.SyntaxKind.AsteriskToken],
-  ["/", ts28.SyntaxKind.SlashToken],
-  ["%", ts28.SyntaxKind.PercentToken],
-  ["!=", ts28.SyntaxKind.ExclamationEqualsToken],
-  ["!==", ts28.SyntaxKind.ExclamationEqualsEqualsToken],
-  ["||", ts28.SyntaxKind.BarBarToken],
-  ["&&", ts28.SyntaxKind.AmpersandAmpersandToken],
-  ["&", ts28.SyntaxKind.AmpersandToken],
-  ["|", ts28.SyntaxKind.BarToken],
-  ["??", ts28.SyntaxKind.QuestionQuestionToken]
+  ["+", ts29.SyntaxKind.PlusToken],
+  ["-", ts29.SyntaxKind.MinusToken],
+  ["<", ts29.SyntaxKind.LessThanToken],
+  [">", ts29.SyntaxKind.GreaterThanToken],
+  ["<=", ts29.SyntaxKind.LessThanEqualsToken],
+  [">=", ts29.SyntaxKind.GreaterThanEqualsToken],
+  ["==", ts29.SyntaxKind.EqualsEqualsToken],
+  ["===", ts29.SyntaxKind.EqualsEqualsEqualsToken],
+  ["*", ts29.SyntaxKind.AsteriskToken],
+  ["/", ts29.SyntaxKind.SlashToken],
+  ["%", ts29.SyntaxKind.PercentToken],
+  ["!=", ts29.SyntaxKind.ExclamationEqualsToken],
+  ["!==", ts29.SyntaxKind.ExclamationEqualsEqualsToken],
+  ["||", ts29.SyntaxKind.BarBarToken],
+  ["&&", ts29.SyntaxKind.AmpersandAmpersandToken],
+  ["&", ts29.SyntaxKind.AmpersandToken],
+  ["|", ts29.SyntaxKind.BarToken],
+  ["??", ts29.SyntaxKind.QuestionQuestionToken]
 ]);
 function astToTypescript(ast, maybeResolve, config) {
   const translator = new AstTranslator(maybeResolve, config);
@@ -3847,7 +5003,7 @@ var AstTranslator = class {
       ast = ast.ast;
     }
     if (ast instanceof EmptyExpr2) {
-      const res = ts28.factory.createIdentifier("undefined");
+      const res = ts29.factory.createIdentifier("undefined");
       addParseSpanInfo(res, ast.sourceSpan);
       return res;
     }
@@ -3863,7 +5019,7 @@ var AstTranslator = class {
     if (op === void 0) {
       throw new Error(`Unsupported Unary.operator: ${ast.operator}`);
     }
-    const node = wrapForDiagnostics(ts28.factory.createPrefixUnaryExpression(op, expr));
+    const node = wrapForDiagnostics(ts29.factory.createPrefixUnaryExpression(op, expr));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -3874,13 +5030,13 @@ var AstTranslator = class {
     if (op === void 0) {
       throw new Error(`Unsupported Binary.operation: ${ast.operation}`);
     }
-    const node = ts28.factory.createBinaryExpression(lhs, op, rhs);
+    const node = ts29.factory.createBinaryExpression(lhs, op, rhs);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitChain(ast) {
     const elements = ast.expressions.map((expr) => this.translate(expr));
-    const node = wrapForDiagnostics(ts28.factory.createCommaListExpression(elements));
+    const node = wrapForDiagnostics(ts29.factory.createCommaListExpression(elements));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -3888,7 +5044,7 @@ var AstTranslator = class {
     const condExpr = this.translate(ast.condition);
     const trueExpr = this.translate(ast.trueExp);
     const falseExpr = wrapForTypeChecker(this.translate(ast.falseExp));
-    const node = ts28.factory.createParenthesizedExpression(ts28.factory.createConditionalExpression(condExpr, void 0, trueExpr, void 0, falseExpr));
+    const node = ts29.factory.createParenthesizedExpression(ts29.factory.createConditionalExpression(condExpr, void 0, trueExpr, void 0, falseExpr));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -3899,26 +5055,26 @@ var AstTranslator = class {
     throw new Error("Method not implemented.");
   }
   visitInterpolation(ast) {
-    return ast.expressions.reduce((lhs, ast2) => ts28.factory.createBinaryExpression(lhs, ts28.SyntaxKind.PlusToken, wrapForTypeChecker(this.translate(ast2))), ts28.factory.createStringLiteral(""));
+    return ast.expressions.reduce((lhs, ast2) => ts29.factory.createBinaryExpression(lhs, ts29.SyntaxKind.PlusToken, wrapForTypeChecker(this.translate(ast2))), ts29.factory.createStringLiteral(""));
   }
   visitKeyedRead(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
     const key = this.translate(ast.key);
-    const node = ts28.factory.createElementAccessExpression(receiver, key);
+    const node = ts29.factory.createElementAccessExpression(receiver, key);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitKeyedWrite(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-    const left = ts28.factory.createElementAccessExpression(receiver, this.translate(ast.key));
+    const left = ts29.factory.createElementAccessExpression(receiver, this.translate(ast.key));
     const right = wrapForTypeChecker(this.translate(ast.value));
-    const node = wrapForDiagnostics(ts28.factory.createBinaryExpression(left, ts28.SyntaxKind.EqualsToken, right));
+    const node = wrapForDiagnostics(ts29.factory.createBinaryExpression(left, ts29.SyntaxKind.EqualsToken, right));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitLiteralArray(ast) {
     const elements = ast.expressions.map((expr) => this.translate(expr));
-    const literal = ts28.factory.createArrayLiteralExpression(elements);
+    const literal = ts29.factory.createArrayLiteralExpression(elements);
     const node = this.config.strictLiteralTypes ? literal : tsCastToAny(literal);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
@@ -3926,9 +5082,9 @@ var AstTranslator = class {
   visitLiteralMap(ast) {
     const properties = ast.keys.map(({ key }, idx) => {
       const value = this.translate(ast.values[idx]);
-      return ts28.factory.createPropertyAssignment(ts28.factory.createStringLiteral(key), value);
+      return ts29.factory.createPropertyAssignment(ts29.factory.createStringLiteral(key), value);
     });
-    const literal = ts28.factory.createObjectLiteralExpression(properties, true);
+    const literal = ts29.factory.createObjectLiteralExpression(properties, true);
     const node = this.config.strictLiteralTypes ? literal : tsCastToAny(literal);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
@@ -3936,15 +5092,15 @@ var AstTranslator = class {
   visitLiteralPrimitive(ast) {
     let node;
     if (ast.value === void 0) {
-      node = ts28.factory.createIdentifier("undefined");
+      node = ts29.factory.createIdentifier("undefined");
     } else if (ast.value === null) {
-      node = ts28.factory.createNull();
+      node = ts29.factory.createNull();
     } else if (typeof ast.value === "string") {
-      node = ts28.factory.createStringLiteral(ast.value);
+      node = ts29.factory.createStringLiteral(ast.value);
     } else if (typeof ast.value === "number") {
       node = tsNumericExpression(ast.value);
     } else if (typeof ast.value === "boolean") {
-      node = ast.value ? ts28.factory.createTrue() : ts28.factory.createFalse();
+      node = ast.value ? ts29.factory.createTrue() : ts29.factory.createFalse();
     } else {
       throw Error(`Unsupported AST value of type ${typeof ast.value}`);
     }
@@ -3953,7 +5109,7 @@ var AstTranslator = class {
   }
   visitNonNullAssert(ast) {
     const expr = wrapForDiagnostics(this.translate(ast.expression));
-    const node = ts28.factory.createNonNullExpression(expr);
+    const node = ts29.factory.createNonNullExpression(expr);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -3962,13 +5118,13 @@ var AstTranslator = class {
   }
   visitPrefixNot(ast) {
     const expression = wrapForDiagnostics(this.translate(ast.expression));
-    const node = ts28.factory.createLogicalNot(expression);
+    const node = ts29.factory.createLogicalNot(expression);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitPropertyRead(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-    const name = ts28.factory.createPropertyAccessExpression(receiver, ast.name);
+    const name = ts29.factory.createPropertyAccessExpression(receiver, ast.name);
     addParseSpanInfo(name, ast.nameSpan);
     const node = wrapForDiagnostics(name);
     addParseSpanInfo(node, ast.sourceSpan);
@@ -3976,12 +5132,12 @@ var AstTranslator = class {
   }
   visitPropertyWrite(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-    const left = ts28.factory.createPropertyAccessExpression(receiver, ast.name);
+    const left = ts29.factory.createPropertyAccessExpression(receiver, ast.name);
     addParseSpanInfo(left, ast.nameSpan);
     const leftWithPath = wrapForDiagnostics(left);
     addParseSpanInfo(leftWithPath, ast.sourceSpan);
     const right = wrapForTypeChecker(this.translate(ast.value));
-    const node = wrapForDiagnostics(ts28.factory.createBinaryExpression(leftWithPath, ts28.SyntaxKind.EqualsToken, right));
+    const node = wrapForDiagnostics(ts29.factory.createBinaryExpression(leftWithPath, ts29.SyntaxKind.EqualsToken, right));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -3989,13 +5145,13 @@ var AstTranslator = class {
     let node;
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
     if (this.config.strictSafeNavigationTypes) {
-      const expr = ts28.factory.createPropertyAccessExpression(ts28.factory.createNonNullExpression(receiver), ast.name);
+      const expr = ts29.factory.createPropertyAccessExpression(ts29.factory.createNonNullExpression(receiver), ast.name);
       addParseSpanInfo(expr, ast.nameSpan);
-      node = ts28.factory.createParenthesizedExpression(ts28.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
+      node = ts29.factory.createParenthesizedExpression(ts29.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
     } else if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
-      node = ts28.factory.createPropertyAccessExpression(tsCastToAny(receiver), ast.name);
+      node = ts29.factory.createPropertyAccessExpression(tsCastToAny(receiver), ast.name);
     } else {
-      const expr = ts28.factory.createPropertyAccessExpression(ts28.factory.createNonNullExpression(receiver), ast.name);
+      const expr = ts29.factory.createPropertyAccessExpression(ts29.factory.createNonNullExpression(receiver), ast.name);
       addParseSpanInfo(expr, ast.nameSpan);
       node = tsCastToAny(expr);
     }
@@ -4007,13 +5163,13 @@ var AstTranslator = class {
     const key = this.translate(ast.key);
     let node;
     if (this.config.strictSafeNavigationTypes) {
-      const expr = ts28.factory.createElementAccessExpression(ts28.factory.createNonNullExpression(receiver), key);
+      const expr = ts29.factory.createElementAccessExpression(ts29.factory.createNonNullExpression(receiver), key);
       addParseSpanInfo(expr, ast.sourceSpan);
-      node = ts28.factory.createParenthesizedExpression(ts28.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
+      node = ts29.factory.createParenthesizedExpression(ts29.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
     } else if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
-      node = ts28.factory.createElementAccessExpression(tsCastToAny(receiver), key);
+      node = ts29.factory.createElementAccessExpression(tsCastToAny(receiver), key);
     } else {
-      const expr = ts28.factory.createElementAccessExpression(ts28.factory.createNonNullExpression(receiver), key);
+      const expr = ts29.factory.createElementAccessExpression(ts29.factory.createNonNullExpression(receiver), key);
       addParseSpanInfo(expr, ast.sourceSpan);
       node = tsCastToAny(expr);
     }
@@ -4030,7 +5186,7 @@ var AstTranslator = class {
         expr = resolved;
       } else {
         const propertyReceiver = wrapForDiagnostics(this.translate(receiver.receiver));
-        expr = ts28.factory.createPropertyAccessExpression(propertyReceiver, receiver.name);
+        expr = ts29.factory.createPropertyAccessExpression(propertyReceiver, receiver.name);
         addParseSpanInfo(expr, receiver.nameSpan);
       }
     } else {
@@ -4040,7 +5196,7 @@ var AstTranslator = class {
     if (ast.receiver instanceof SafePropertyRead2 || ast.receiver instanceof SafeKeyedRead) {
       node = this.convertToSafeCall(ast, expr, args);
     } else {
-      node = ts28.factory.createCallExpression(expr, void 0, args);
+      node = ts29.factory.createCallExpression(expr, void 0, args);
     }
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
@@ -4054,13 +5210,13 @@ var AstTranslator = class {
   }
   convertToSafeCall(ast, expr, args) {
     if (this.config.strictSafeNavigationTypes) {
-      const call = ts28.factory.createCallExpression(ts28.factory.createNonNullExpression(expr), void 0, args);
-      return ts28.factory.createParenthesizedExpression(ts28.factory.createConditionalExpression(NULL_AS_ANY, void 0, call, void 0, UNDEFINED));
+      const call = ts29.factory.createCallExpression(ts29.factory.createNonNullExpression(expr), void 0, args);
+      return ts29.factory.createParenthesizedExpression(ts29.factory.createConditionalExpression(NULL_AS_ANY, void 0, call, void 0, UNDEFINED));
     }
     if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
-      return ts28.factory.createCallExpression(tsCastToAny(expr), void 0, args);
+      return ts29.factory.createCallExpression(tsCastToAny(expr), void 0, args);
     }
-    return tsCastToAny(ts28.factory.createCallExpression(ts28.factory.createNonNullExpression(expr), void 0, args));
+    return tsCastToAny(ts29.factory.createCallExpression(ts29.factory.createNonNullExpression(expr), void 0, args));
   }
 };
 var _VeSafeLhsInferenceBugDetector = class {
@@ -4148,7 +5304,7 @@ function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecor
   const tcb = new Context(env, domSchemaChecker, oobRecorder, meta.id, meta.boundTarget, meta.pipes, meta.schemas, meta.isStandalone, meta.preserveWhitespaces);
   const scope = Scope.forNodes(tcb, null, null, tcb.boundTarget.target.template, null);
   const ctxRawType = env.referenceType(ref);
-  if (!ts29.isTypeReferenceNode(ctxRawType)) {
+  if (!ts30.isTypeReferenceNode(ctxRawType)) {
     throw new Error(`Expected TypeReferenceNode when referencing the ctx param for ${ref.debugName}`);
   }
   let typeParameters = void 0;
@@ -4160,25 +5316,25 @@ function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecor
     switch (genericContextBehavior) {
       case TcbGenericContextBehavior.UseEmitter:
         typeParameters = new TypeParameterEmitter(ref.node.typeParameters, env.reflector).emit((typeRef) => env.referenceType(typeRef));
-        typeArguments = typeParameters.map((param) => ts29.factory.createTypeReferenceNode(param.name));
+        typeArguments = typeParameters.map((param) => ts30.factory.createTypeReferenceNode(param.name));
         break;
       case TcbGenericContextBehavior.CopyClassNodes:
         typeParameters = [...ref.node.typeParameters];
-        typeArguments = typeParameters.map((param) => ts29.factory.createTypeReferenceNode(param.name));
+        typeArguments = typeParameters.map((param) => ts30.factory.createTypeReferenceNode(param.name));
         break;
       case TcbGenericContextBehavior.FallbackToAny:
-        typeArguments = ref.node.typeParameters.map(() => ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword));
+        typeArguments = ref.node.typeParameters.map(() => ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword));
         break;
     }
   }
   const paramList = [tcbThisParam(ctxRawType.typeName, typeArguments)];
   const scopeStatements = scope.render();
-  const innerBody = ts29.factory.createBlock([
+  const innerBody = ts30.factory.createBlock([
     ...env.getPreludeStatements(),
     ...scopeStatements
   ]);
-  const body = ts29.factory.createBlock([ts29.factory.createIfStatement(ts29.factory.createTrue(), innerBody, void 0)]);
-  const fnDecl = ts29.factory.createFunctionDeclaration(
+  const body = ts30.factory.createBlock([ts30.factory.createIfStatement(ts30.factory.createTrue(), innerBody, void 0)]);
+  const fnDecl = ts30.factory.createFunctionDeclaration(
     void 0,
     void 0,
     name,
@@ -4227,7 +5383,7 @@ var TcbTemplateVariableOp = class extends TcbOp {
   execute() {
     const ctx = this.scope.resolve(this.template);
     const id = this.tcb.allocateId();
-    const initializer = ts29.factory.createPropertyAccessExpression(
+    const initializer = ts30.factory.createPropertyAccessExpression(
       ctx,
       this.variable.value || "$implicit"
     );
@@ -4253,7 +5409,7 @@ var TcbTemplateContextOp = class extends TcbOp {
   }
   execute() {
     const ctx = this.tcb.allocateId();
-    const type = ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword);
+    const type = ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword);
     this.scope.addStatement(tsDeclareVariable(ctx, type));
     return ctx;
   }
@@ -4306,16 +5462,16 @@ var TcbTemplateBodyOp = class extends TcbOp {
     }
     let guard = null;
     if (directiveGuards.length > 0) {
-      guard = directiveGuards.reduce((expr, dirGuard) => ts29.factory.createBinaryExpression(expr, ts29.SyntaxKind.AmpersandAmpersandToken, dirGuard), directiveGuards.pop());
+      guard = directiveGuards.reduce((expr, dirGuard) => ts30.factory.createBinaryExpression(expr, ts30.SyntaxKind.AmpersandAmpersandToken, dirGuard), directiveGuards.pop());
     }
     const tmplScope = Scope.forNodes(this.tcb, this.scope, this.template, this.template.children, guard);
     const statements = tmplScope.render();
     if (statements.length === 0) {
       return null;
     }
-    let tmplBlock = ts29.factory.createBlock(statements);
+    let tmplBlock = ts30.factory.createBlock(statements);
     if (guard !== null) {
-      tmplBlock = ts29.factory.createIfStatement(guard, tmplBlock);
+      tmplBlock = ts30.factory.createIfStatement(guard, tmplBlock);
     }
     this.scope.addStatement(tmplBlock);
     return null;
@@ -4333,7 +5489,7 @@ var TcbExpressionOp = class extends TcbOp {
   }
   execute() {
     const expr = tcbExpression(this.expression, this.tcb, this.scope);
-    this.scope.addStatement(ts29.factory.createExpressionStatement(expr));
+    this.scope.addStatement(ts30.factory.createExpressionStatement(expr));
     return null;
   }
 };
@@ -4355,11 +5511,11 @@ var TcbDirectiveTypeOpBase = class extends TcbOp {
     if (this.dir.isGeneric === false || dirRef.node.typeParameters === void 0) {
       type = rawType;
     } else {
-      if (!ts29.isTypeReferenceNode(rawType)) {
+      if (!ts30.isTypeReferenceNode(rawType)) {
         throw new Error(`Expected TypeReferenceNode when referencing the type for ${this.dir.ref.debugName}`);
       }
-      const typeArguments = dirRef.node.typeParameters.map(() => ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword));
-      type = ts29.factory.createTypeReferenceNode(rawType.typeName, typeArguments);
+      const typeArguments = dirRef.node.typeParameters.map(() => ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword));
+      type = ts30.factory.createTypeReferenceNode(rawType.typeName, typeArguments);
     }
     const id = this.tcb.allocateId();
     addExpressionIdentifier(id, ExpressionIdentifier.DIRECTIVE);
@@ -4400,11 +5556,11 @@ var TcbReferenceOp = class extends TcbOp {
     const id = this.tcb.allocateId();
     let initializer = this.target instanceof TmplAstTemplate2 || this.target instanceof TmplAstElement3 ? this.scope.resolve(this.target) : this.scope.resolve(this.host, this.target);
     if (this.target instanceof TmplAstElement3 && !this.tcb.env.config.checkTypeOfDomReferences || !this.tcb.env.config.checkTypeOfNonDomReferences) {
-      initializer = ts29.factory.createAsExpression(initializer, ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword));
+      initializer = ts30.factory.createAsExpression(initializer, ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword));
     } else if (this.target instanceof TmplAstTemplate2) {
-      initializer = ts29.factory.createAsExpression(initializer, ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword));
-      initializer = ts29.factory.createAsExpression(initializer, this.tcb.env.referenceExternalType("@angular/core", "TemplateRef", [DYNAMIC_TYPE]));
-      initializer = ts29.factory.createParenthesizedExpression(initializer);
+      initializer = ts30.factory.createAsExpression(initializer, ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword));
+      initializer = ts30.factory.createAsExpression(initializer, this.tcb.env.referenceExternalType("@angular/core", "TemplateRef", [DYNAMIC_TYPE]));
+      initializer = ts30.factory.createParenthesizedExpression(initializer);
     }
     addParseSpanInfo(initializer, this.node.sourceSpan);
     addParseSpanInfo(id, this.node.keySpan);
@@ -4503,7 +5659,7 @@ var TcbDirectiveInputsOp = class extends TcbOp {
             type = this.tcb.env.referenceTransplantedType(new TransplantedType(transformType));
           } else {
             const dirTypeRef = this.tcb.env.referenceType(this.dir.ref);
-            if (!ts29.isTypeReferenceNode(dirTypeRef)) {
+            if (!ts30.isTypeReferenceNode(dirTypeRef)) {
               throw new Error(`Expected TypeReferenceNode from reference to ${this.dir.ref.debugName}`);
             }
             type = tsCreateTypeQueryForCoercedInput(dirTypeRef.typeName, fieldName);
@@ -4519,10 +5675,10 @@ var TcbDirectiveInputsOp = class extends TcbOp {
           }
           const id = this.tcb.allocateId();
           const dirTypeRef = this.tcb.env.referenceType(this.dir.ref);
-          if (!ts29.isTypeReferenceNode(dirTypeRef)) {
+          if (!ts30.isTypeReferenceNode(dirTypeRef)) {
             throw new Error(`Expected TypeReferenceNode from reference to ${this.dir.ref.debugName}`);
           }
-          const type = ts29.factory.createIndexedAccessTypeNode(ts29.factory.createTypeQueryNode(dirId), ts29.factory.createLiteralTypeNode(ts29.factory.createStringLiteral(fieldName)));
+          const type = ts30.factory.createIndexedAccessTypeNode(ts30.factory.createTypeQueryNode(dirId), ts30.factory.createLiteralTypeNode(ts30.factory.createStringLiteral(fieldName)));
           const temp = tsDeclareVariable(id, type);
           this.scope.addStatement(temp);
           target = id;
@@ -4530,14 +5686,14 @@ var TcbDirectiveInputsOp = class extends TcbOp {
           if (dirId === null) {
             dirId = this.scope.resolve(this.node, this.dir);
           }
-          target = this.dir.stringLiteralInputFields.has(fieldName) ? ts29.factory.createElementAccessExpression(dirId, ts29.factory.createStringLiteral(fieldName)) : ts29.factory.createPropertyAccessExpression(dirId, ts29.factory.createIdentifier(fieldName));
+          target = this.dir.stringLiteralInputFields.has(fieldName) ? ts30.factory.createElementAccessExpression(dirId, ts30.factory.createStringLiteral(fieldName)) : ts30.factory.createPropertyAccessExpression(dirId, ts30.factory.createIdentifier(fieldName));
         }
         if (isSignal) {
           const inputSignalBrandWriteSymbol = this.tcb.env.referenceExternalSymbol(R3Identifiers3.InputSignalBrandWriteType.moduleName, R3Identifiers3.InputSignalBrandWriteType.name);
-          if (!ts29.isIdentifier(inputSignalBrandWriteSymbol) && !ts29.isPropertyAccessExpression(inputSignalBrandWriteSymbol)) {
+          if (!ts30.isIdentifier(inputSignalBrandWriteSymbol) && !ts30.isPropertyAccessExpression(inputSignalBrandWriteSymbol)) {
             throw new Error(`Expected identifier or property access for reference to ${R3Identifiers3.InputSignalBrandWriteType.name}`);
           }
-          target = ts29.factory.createElementAccessExpression(target, inputSignalBrandWriteSymbol);
+          target = ts30.factory.createElementAccessExpression(target, inputSignalBrandWriteSymbol);
         }
         if (attr.attribute.keySpan !== void 0) {
           addParseSpanInfo(target, attr.attribute.keySpan);
@@ -4545,13 +5701,13 @@ var TcbDirectiveInputsOp = class extends TcbOp {
         if (isTwoWayBinding && this.tcb.env.config.allowSignalsInTwoWayBindings) {
           assignment = unwrapWritableSignal(assignment, this.tcb);
         }
-        assignment = ts29.factory.createBinaryExpression(target, ts29.SyntaxKind.EqualsToken, assignment);
+        assignment = ts30.factory.createBinaryExpression(target, ts30.SyntaxKind.EqualsToken, assignment);
       }
       addParseSpanInfo(assignment, attr.attribute.sourceSpan);
       if (!this.tcb.env.config.checkTypeOfAttributes && attr.attribute instanceof TmplAstTextAttribute2) {
         markIgnoreDiagnostics(assignment);
       }
-      this.scope.addStatement(ts29.factory.createExpressionStatement(assignment));
+      this.scope.addStatement(ts30.factory.createExpressionStatement(assignment));
     }
     this.checkRequiredInputs(seenRequiredInputs);
     return null;
@@ -4582,7 +5738,7 @@ var TcbDirectiveCtorCircularFallbackOp = class extends TcbOp {
   execute() {
     const id = this.tcb.allocateId();
     const typeCtor = this.tcb.env.typeCtorFor(this.dir);
-    const circularPlaceholder = ts29.factory.createCallExpression(typeCtor, void 0, [ts29.factory.createNonNullExpression(ts29.factory.createNull())]);
+    const circularPlaceholder = ts30.factory.createCallExpression(typeCtor, void 0, [ts30.factory.createNonNullExpression(ts30.factory.createNull())]);
     this.scope.addStatement(tsCreateVariable(id, circularPlaceholder));
     return id;
   }
@@ -4624,7 +5780,7 @@ var TcbControlFlowContentProjectionOp = class extends TcbOp {
     this.ngContentSelectors = ngContentSelectors;
     this.componentName = componentName;
     this.optional = false;
-    this.category = tcb.env.config.controlFlowPreventingContentProjection === "error" ? ts29.DiagnosticCategory.Error : ts29.DiagnosticCategory.Warning;
+    this.category = tcb.env.config.controlFlowPreventingContentProjection === "error" ? ts30.DiagnosticCategory.Error : ts30.DiagnosticCategory.Warning;
   }
   execute() {
     const controlFlowToCheck = this.findPotentialControlFlowNodes();
@@ -4723,15 +5879,15 @@ var TcbUnclaimedInputsOp = class extends TcbOp {
             elId = this.scope.resolve(this.element);
           }
           const propertyName = (_a = ATTR_TO_PROP.get(binding.name)) != null ? _a : binding.name;
-          const prop = ts29.factory.createElementAccessExpression(elId, ts29.factory.createStringLiteral(propertyName));
-          const stmt = ts29.factory.createBinaryExpression(prop, ts29.SyntaxKind.EqualsToken, wrapForDiagnostics(expr));
+          const prop = ts30.factory.createElementAccessExpression(elId, ts30.factory.createStringLiteral(propertyName));
+          const stmt = ts30.factory.createBinaryExpression(prop, ts30.SyntaxKind.EqualsToken, wrapForDiagnostics(expr));
           addParseSpanInfo(stmt, binding.sourceSpan);
-          this.scope.addStatement(ts29.factory.createExpressionStatement(stmt));
+          this.scope.addStatement(ts30.factory.createExpressionStatement(stmt));
         } else {
-          this.scope.addStatement(ts29.factory.createExpressionStatement(expr));
+          this.scope.addStatement(ts30.factory.createExpressionStatement(expr));
         }
       } else {
-        this.scope.addStatement(ts29.factory.createExpressionStatement(expr));
+        this.scope.addStatement(ts30.factory.createExpressionStatement(expr));
       }
     }
     return null;
@@ -4763,18 +5919,18 @@ var TcbDirectiveOutputsOp = class extends TcbOp {
       if (dirId === null) {
         dirId = this.scope.resolve(this.node, this.dir);
       }
-      const outputField = ts29.factory.createElementAccessExpression(dirId, ts29.factory.createStringLiteral(field));
+      const outputField = ts30.factory.createElementAccessExpression(dirId, ts30.factory.createStringLiteral(field));
       addParseSpanInfo(outputField, output.keySpan);
       if (this.tcb.env.config.checkTypeOfOutputEvents) {
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 0);
-        const subscribeFn = ts29.factory.createPropertyAccessExpression(outputField, "subscribe");
-        const call = ts29.factory.createCallExpression(subscribeFn, void 0, [handler]);
+        const subscribeFn = ts30.factory.createPropertyAccessExpression(outputField, "subscribe");
+        const call = ts30.factory.createCallExpression(subscribeFn, void 0, [handler]);
         addParseSpanInfo(call, output.sourceSpan);
-        this.scope.addStatement(ts29.factory.createExpressionStatement(call));
+        this.scope.addStatement(ts30.factory.createExpressionStatement(call));
       } else {
-        this.scope.addStatement(ts29.factory.createExpressionStatement(outputField));
+        this.scope.addStatement(ts30.factory.createExpressionStatement(outputField));
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 1);
-        this.scope.addStatement(ts29.factory.createExpressionStatement(handler));
+        this.scope.addStatement(ts30.factory.createExpressionStatement(handler));
       }
     }
     return null;
@@ -4806,24 +5962,24 @@ var TcbUnclaimedOutputsOp = class extends TcbOp {
       if (output.type === 1) {
         const eventType = this.tcb.env.config.checkTypeOfAnimationEvents ? this.tcb.env.referenceExternalType("@angular/animations", "AnimationEvent") : 1;
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, eventType);
-        this.scope.addStatement(ts29.factory.createExpressionStatement(handler));
+        this.scope.addStatement(ts30.factory.createExpressionStatement(handler));
       } else if (this.tcb.env.config.checkTypeOfDomEvents) {
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 0);
         if (elId === null) {
           elId = this.scope.resolve(this.element);
         }
-        const propertyAccess = ts29.factory.createPropertyAccessExpression(elId, "addEventListener");
+        const propertyAccess = ts30.factory.createPropertyAccessExpression(elId, "addEventListener");
         addParseSpanInfo(propertyAccess, output.keySpan);
-        const call = ts29.factory.createCallExpression(
+        const call = ts30.factory.createCallExpression(
           propertyAccess,
           void 0,
-          [ts29.factory.createStringLiteral(output.name), handler]
+          [ts30.factory.createStringLiteral(output.name), handler]
         );
         addParseSpanInfo(call, output.sourceSpan);
-        this.scope.addStatement(ts29.factory.createExpressionStatement(call));
+        this.scope.addStatement(ts30.factory.createExpressionStatement(call));
       } else {
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 1);
-        this.scope.addStatement(ts29.factory.createExpressionStatement(handler));
+        this.scope.addStatement(ts30.factory.createExpressionStatement(handler));
       }
     }
     return null;
@@ -4836,11 +5992,11 @@ var TcbComponentContextCompletionOp = class extends TcbOp {
     this.optional = false;
   }
   execute() {
-    const ctx = ts29.factory.createThis();
-    const ctxDot = ts29.factory.createPropertyAccessExpression(ctx, "");
+    const ctx = ts30.factory.createThis();
+    const ctxDot = ts30.factory.createPropertyAccessExpression(ctx, "");
     markIgnoreDiagnostics(ctxDot);
     addExpressionIdentifier(ctxDot, ExpressionIdentifier.COMPONENT_COMPLETION);
-    this.scope.addStatement(ts29.factory.createExpressionStatement(ctxDot));
+    this.scope.addStatement(ts30.factory.createExpressionStatement(ctxDot));
     return null;
   }
 };
@@ -4905,14 +6061,14 @@ var TcbIfOp = class extends TcbOp {
     }
     if (branch.expression === null) {
       const branchScope = Scope.forNodes(this.tcb, this.scope, null, branch.children, this.generateBranchGuard(index));
-      return ts29.factory.createBlock(branchScope.render());
+      return ts30.factory.createBlock(branchScope.render());
     }
     const expressionScope = Scope.forNodes(this.tcb, this.scope, branch, [], null);
     expressionScope.render().forEach((stmt) => this.scope.addStatement(stmt));
     this.expressionScopes.set(branch, expressionScope);
     const expression = branch.expressionAlias === null ? tcbExpression(branch.expression, this.tcb, expressionScope) : expressionScope.resolve(branch.expressionAlias);
     const bodyScope = Scope.forNodes(this.tcb, expressionScope, null, branch.children, this.generateBranchGuard(index));
-    return ts29.factory.createIfStatement(expression, ts29.factory.createBlock(bodyScope.render()), this.generateBranch(index + 1));
+    return ts30.factory.createIfStatement(expression, ts30.factory.createBlock(bodyScope.render()), this.generateBranch(index + 1));
   }
   generateBranchGuard(index) {
     let guard = null;
@@ -4932,8 +6088,8 @@ var TcbIfOp = class extends TcbOp {
       } else {
         expression = expressionScope.resolve(branch.expressionAlias);
       }
-      const comparisonExpression = i === index ? expression : ts29.factory.createPrefixUnaryExpression(ts29.SyntaxKind.ExclamationToken, ts29.factory.createParenthesizedExpression(expression));
-      guard = guard === null ? comparisonExpression : ts29.factory.createBinaryExpression(guard, ts29.SyntaxKind.AmpersandAmpersandToken, comparisonExpression);
+      const comparisonExpression = i === index ? expression : ts30.factory.createPrefixUnaryExpression(ts30.SyntaxKind.ExclamationToken, ts30.factory.createParenthesizedExpression(expression));
+      guard = guard === null ? comparisonExpression : ts30.factory.createBinaryExpression(guard, ts30.SyntaxKind.AmpersandAmpersandToken, comparisonExpression);
     }
     return guard;
   }
@@ -4951,7 +6107,7 @@ var TcbSwitchOp = class extends TcbOp {
   execute() {
     const comparisonExpression = tcbExpression(this.block.expression, this.tcb, this.scope);
     markIgnoreDiagnostics(comparisonExpression);
-    const expression = ts29.factory.createParenthesizedExpression(comparisonExpression);
+    const expression = ts30.factory.createParenthesizedExpression(comparisonExpression);
     const root = this.generateCase(0, expression, null);
     if (root !== void 0) {
       this.scope.addStatement(root);
@@ -4962,7 +6118,7 @@ var TcbSwitchOp = class extends TcbOp {
     if (index >= this.block.cases.length) {
       if (defaultCase !== null) {
         const defaultScope = Scope.forNodes(this.tcb, this.scope, null, defaultCase.children, this.generateGuard(defaultCase, switchValue));
-        return ts29.factory.createBlock(defaultScope.render());
+        return ts30.factory.createBlock(defaultScope.render());
       }
       return void 0;
     }
@@ -4972,13 +6128,13 @@ var TcbSwitchOp = class extends TcbOp {
     }
     const caseScope = Scope.forNodes(this.tcb, this.scope, null, current.children, this.generateGuard(current, switchValue));
     const caseValue = tcbExpression(current.expression, this.tcb, caseScope);
-    return ts29.factory.createIfStatement(ts29.factory.createBinaryExpression(switchValue, ts29.SyntaxKind.EqualsEqualsEqualsToken, caseValue), ts29.factory.createBlock(caseScope.render()), this.generateCase(index + 1, switchValue, defaultCase));
+    return ts30.factory.createIfStatement(ts30.factory.createBinaryExpression(switchValue, ts30.SyntaxKind.EqualsEqualsEqualsToken, caseValue), ts30.factory.createBlock(caseScope.render()), this.generateCase(index + 1, switchValue, defaultCase));
   }
   generateGuard(node, switchValue) {
     if (node.expression !== null) {
       const expression = tcbExpression(node.expression, this.tcb, this.scope);
       markIgnoreDiagnostics(expression);
-      return ts29.factory.createBinaryExpression(switchValue, ts29.SyntaxKind.EqualsEqualsEqualsToken, expression);
+      return ts30.factory.createBinaryExpression(switchValue, ts30.SyntaxKind.EqualsEqualsEqualsToken, expression);
     }
     let guard = null;
     for (const current of this.block.cases) {
@@ -4987,11 +6143,11 @@ var TcbSwitchOp = class extends TcbOp {
       }
       const expression = tcbExpression(current.expression, this.tcb, this.scope);
       markIgnoreDiagnostics(expression);
-      const comparison = ts29.factory.createBinaryExpression(switchValue, ts29.SyntaxKind.ExclamationEqualsEqualsToken, expression);
+      const comparison = ts30.factory.createBinaryExpression(switchValue, ts30.SyntaxKind.ExclamationEqualsEqualsToken, expression);
       if (guard === null) {
         guard = comparison;
       } else {
-        guard = ts29.factory.createBinaryExpression(guard, ts29.SyntaxKind.AmpersandAmpersandToken, comparison);
+        guard = ts30.factory.createBinaryExpression(guard, ts30.SyntaxKind.AmpersandAmpersandToken, comparison);
       }
     }
     return guard;
@@ -5010,23 +6166,23 @@ var TcbForOfOp = class extends TcbOp {
   execute() {
     const loopScope = Scope.forNodes(this.tcb, this.scope, this.block, this.block.children, null);
     const initializerId = loopScope.resolve(this.block.item);
-    if (!ts29.isIdentifier(initializerId)) {
+    if (!ts30.isIdentifier(initializerId)) {
       throw new Error(`Could not resolve for loop variable ${this.block.item.name} to an identifier`);
     }
-    const initializer = ts29.factory.createVariableDeclarationList([ts29.factory.createVariableDeclaration(initializerId)], ts29.NodeFlags.Const);
+    const initializer = ts30.factory.createVariableDeclarationList([ts30.factory.createVariableDeclaration(initializerId)], ts30.NodeFlags.Const);
     addParseSpanInfo(initializer, this.block.item.keySpan);
-    const expression = ts29.factory.createNonNullExpression(tcbExpression(this.block.expression, this.tcb, loopScope));
+    const expression = ts30.factory.createNonNullExpression(tcbExpression(this.block.expression, this.tcb, loopScope));
     const trackTranslator = new TcbForLoopTrackTranslator(this.tcb, loopScope, this.block);
     const trackExpression = trackTranslator.translate(this.block.trackBy);
     const statements = [
       ...loopScope.render(),
-      ts29.factory.createExpressionStatement(trackExpression)
+      ts30.factory.createExpressionStatement(trackExpression)
     ];
-    this.scope.addStatement(ts29.factory.createForOfStatement(void 0, initializer, expression, ts29.factory.createBlock(statements)));
+    this.scope.addStatement(ts30.factory.createForOfStatement(void 0, initializer, expression, ts30.factory.createBlock(statements)));
     return null;
   }
 };
-var INFER_TYPE_FOR_CIRCULAR_OP_EXPR = ts29.factory.createNonNullExpression(ts29.factory.createNull());
+var INFER_TYPE_FOR_CIRCULAR_OP_EXPR = ts30.factory.createNonNullExpression(ts30.factory.createNull());
 var Context = class {
   constructor(env, domSchemaChecker, oobRecorder, id, boundTarget, pipes, schemas, hostIsStandalone, hostPreserveWhitespaces) {
     this.env = env;
@@ -5041,7 +6197,7 @@ var Context = class {
     this.nextId = 1;
   }
   allocateId() {
-    return ts29.factory.createIdentifier(`_t${this.nextId++}`);
+    return ts30.factory.createIdentifier(`_t${this.nextId++}`);
   }
   getPipeByName(name) {
     if (!this.pipes.has(name)) {
@@ -5092,7 +6248,7 @@ var _Scope = class {
         if (!this.forLoopContextVariableTypes.has(name)) {
           throw new Error(`Unrecognized for loop context variable ${name}`);
         }
-        const type = ts29.factory.createKeywordTypeNode(this.forLoopContextVariableTypes.get(name));
+        const type = ts30.factory.createKeywordTypeNode(this.forLoopContextVariableTypes.get(name));
         this.registerVariable(scope, variable, new TcbBlockImplicitVariableOp(tcb, scope, type, variable));
       }
     }
@@ -5109,16 +6265,16 @@ var _Scope = class {
     const res = this.resolveLocal(node, directive);
     if (res !== null) {
       let clone;
-      if (ts29.isIdentifier(res)) {
-        clone = ts29.factory.createIdentifier(res.text);
-      } else if (ts29.isNonNullExpression(res)) {
-        clone = ts29.factory.createNonNullExpression(res.expression);
+      if (ts30.isIdentifier(res)) {
+        clone = ts30.factory.createIdentifier(res.text);
+      } else if (ts30.isNonNullExpression(res)) {
+        clone = ts30.factory.createNonNullExpression(res.expression);
       } else {
         throw new Error(`Could not resolve ${node} to an Identifier or a NonNullExpression`);
       }
-      ts29.setOriginalNode(clone, res);
+      ts30.setOriginalNode(clone, res);
       clone.parent = clone.parent;
-      return ts29.setSyntheticTrailingComments(clone, []);
+      return ts30.setSyntheticTrailingComments(clone, []);
     } else if (this.parent !== null) {
       return this.parent.resolve(node, directive);
     } else {
@@ -5145,7 +6301,7 @@ var _Scope = class {
     } else if (parentGuards === null) {
       return this.guard;
     } else {
-      return ts29.factory.createBinaryExpression(parentGuards, ts29.SyntaxKind.AmpersandAmpersandToken, this.guard);
+      return ts30.factory.createBinaryExpression(parentGuards, ts30.SyntaxKind.AmpersandAmpersandToken, this.guard);
     }
   }
   resolveLocal(ref, directive) {
@@ -5393,21 +6549,21 @@ var _Scope = class {
 var Scope = _Scope;
 (() => {
   _Scope.forLoopContextVariableTypes = /* @__PURE__ */ new Map([
-    ["$first", ts29.SyntaxKind.BooleanKeyword],
-    ["$last", ts29.SyntaxKind.BooleanKeyword],
-    ["$even", ts29.SyntaxKind.BooleanKeyword],
-    ["$odd", ts29.SyntaxKind.BooleanKeyword],
-    ["$index", ts29.SyntaxKind.NumberKeyword],
-    ["$count", ts29.SyntaxKind.NumberKeyword]
+    ["$first", ts30.SyntaxKind.BooleanKeyword],
+    ["$last", ts30.SyntaxKind.BooleanKeyword],
+    ["$even", ts30.SyntaxKind.BooleanKeyword],
+    ["$odd", ts30.SyntaxKind.BooleanKeyword],
+    ["$index", ts30.SyntaxKind.NumberKeyword],
+    ["$count", ts30.SyntaxKind.NumberKeyword]
   ]);
 })();
 function tcbThisParam(name, typeArguments) {
-  return ts29.factory.createParameterDeclaration(
+  return ts30.factory.createParameterDeclaration(
     void 0,
     void 0,
     "this",
     void 0,
-    ts29.factory.createTypeReferenceNode(name, typeArguments),
+    ts30.factory.createTypeReferenceNode(name, typeArguments),
     void 0
   );
 }
@@ -5432,11 +6588,11 @@ var TcbExpressionTranslator = class {
         return null;
       }
       const expr = this.translate(ast.value);
-      const result = ts29.factory.createParenthesizedExpression(ts29.factory.createBinaryExpression(target, ts29.SyntaxKind.EqualsToken, expr));
+      const result = ts30.factory.createParenthesizedExpression(ts30.factory.createBinaryExpression(target, ts30.SyntaxKind.EqualsToken, expr));
       addParseSpanInfo(result, ast.sourceSpan);
       return result;
     } else if (ast instanceof ImplicitReceiver3) {
-      return ts29.factory.createThis();
+      return ts30.factory.createThis();
     } else if (ast instanceof BindingPipe) {
       const expr = this.translate(ast.exp);
       const pipeMeta = this.tcb.getPipeByName(ast.name);
@@ -5451,12 +6607,12 @@ var TcbExpressionTranslator = class {
         pipe = this.tcb.env.pipeInst(pipeMeta.ref);
       }
       const args = ast.args.map((arg) => this.translate(arg));
-      let methodAccess = ts29.factory.createPropertyAccessExpression(pipe, "transform");
+      let methodAccess = ts30.factory.createPropertyAccessExpression(pipe, "transform");
       addParseSpanInfo(methodAccess, ast.nameSpan);
       if (!this.tcb.env.config.checkTypeOfPipes) {
-        methodAccess = ts29.factory.createAsExpression(methodAccess, ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword));
+        methodAccess = ts30.factory.createAsExpression(methodAccess, ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword));
       }
-      const result = ts29.factory.createCallExpression(
+      const result = ts30.factory.createCallExpression(
         methodAccess,
         void 0,
         [expr, ...args]
@@ -5466,8 +6622,8 @@ var TcbExpressionTranslator = class {
     } else if ((ast instanceof Call2 || ast instanceof SafeCall) && (ast.receiver instanceof PropertyRead4 || ast.receiver instanceof SafePropertyRead3)) {
       if (ast.receiver.receiver instanceof ImplicitReceiver3 && !(ast.receiver.receiver instanceof ThisReceiver) && ast.receiver.name === "$any" && ast.args.length === 1) {
         const expr = this.translate(ast.args[0]);
-        const exprAsAny = ts29.factory.createAsExpression(expr, ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword));
-        const result = ts29.factory.createParenthesizedExpression(exprAsAny);
+        const exprAsAny = ts30.factory.createAsExpression(expr, ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword));
+        const result = ts30.factory.createParenthesizedExpression(exprAsAny);
         addParseSpanInfo(result, ast.sourceSpan);
         return result;
       }
@@ -5478,7 +6634,7 @@ var TcbExpressionTranslator = class {
       const method = wrapForDiagnostics(receiver);
       addParseSpanInfo(method, ast.receiver.nameSpan);
       const args = ast.args.map((arg) => this.translate(arg));
-      const node = ts29.factory.createCallExpression(method, void 0, args);
+      const node = ts30.factory.createCallExpression(method, void 0, args);
       addParseSpanInfo(node, ast.sourceSpan);
       return node;
     } else {
@@ -5498,23 +6654,23 @@ var TcbExpressionTranslator = class {
 function tcbCallTypeCtor(dir, tcb, inputs) {
   const typeCtor = tcb.env.typeCtorFor(dir);
   const members = inputs.map((input) => {
-    const propertyName = ts29.factory.createStringLiteral(input.field);
+    const propertyName = ts30.factory.createStringLiteral(input.field);
     if (input.type === "binding") {
       let expr = widenBinding(input.expression, tcb);
       if (input.isTwoWayBinding && tcb.env.config.allowSignalsInTwoWayBindings) {
         expr = unwrapWritableSignal(expr, tcb);
       }
-      const assignment = ts29.factory.createPropertyAssignment(propertyName, wrapForDiagnostics(expr));
+      const assignment = ts30.factory.createPropertyAssignment(propertyName, wrapForDiagnostics(expr));
       addParseSpanInfo(assignment, input.sourceSpan);
       return assignment;
     } else {
-      return ts29.factory.createPropertyAssignment(propertyName, NULL_AS_ANY);
+      return ts30.factory.createPropertyAssignment(propertyName, NULL_AS_ANY);
     }
   });
-  return ts29.factory.createCallExpression(
+  return ts30.factory.createCallExpression(
     typeCtor,
     void 0,
-    [ts29.factory.createObjectLiteralExpression(members)]
+    [ts30.factory.createObjectLiteralExpression(members)]
   );
 }
 function getBoundAttributes(directive, node) {
@@ -5551,17 +6707,17 @@ function translateInput(attr, tcb, scope) {
   if (attr instanceof TmplAstBoundAttribute) {
     return tcbExpression(attr.value, tcb, scope);
   } else {
-    return ts29.factory.createStringLiteral(attr.value);
+    return ts30.factory.createStringLiteral(attr.value);
   }
 }
 function widenBinding(expr, tcb) {
   if (!tcb.env.config.checkTypeOfInputBindings) {
     return tsCastToAny(expr);
   } else if (!tcb.env.config.strictNullInputBindings) {
-    if (ts29.isObjectLiteralExpression(expr) || ts29.isArrayLiteralExpression(expr)) {
+    if (ts30.isObjectLiteralExpression(expr) || ts30.isArrayLiteralExpression(expr)) {
       return expr;
     } else {
-      return ts29.factory.createNonNullExpression(expr);
+      return ts30.factory.createNonNullExpression(expr);
     }
   } else {
     return expr;
@@ -5569,7 +6725,7 @@ function widenBinding(expr, tcb) {
 }
 function unwrapWritableSignal(expression, tcb) {
   const unwrapRef = tcb.env.referenceExternalSymbol(R3Identifiers3.unwrapWritableSignal.moduleName, R3Identifiers3.unwrapWritableSignal.name);
-  return ts29.factory.createCallExpression(unwrapRef, void 0, [expression]);
+  return ts30.factory.createCallExpression(unwrapRef, void 0, [expression]);
 }
 var EVENT_PARAMETER = "$event";
 function tcbCreateEventHandler(event, tcb, scope, eventType) {
@@ -5578,16 +6734,16 @@ function tcbCreateEventHandler(event, tcb, scope, eventType) {
   if (eventType === 0) {
     eventParamType = void 0;
   } else if (eventType === 1) {
-    eventParamType = ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword);
+    eventParamType = ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword);
   } else {
     eventParamType = eventType;
   }
   const guards = scope.guards();
-  let body = ts29.factory.createExpressionStatement(handler);
+  let body = ts30.factory.createExpressionStatement(handler);
   if (guards !== null) {
-    body = ts29.factory.createIfStatement(guards, body);
+    body = ts30.factory.createIfStatement(guards, body);
   }
-  const eventParam = ts29.factory.createParameterDeclaration(
+  const eventParam = ts30.factory.createParameterDeclaration(
     void 0,
     void 0,
     EVENT_PARAMETER,
@@ -5595,13 +6751,13 @@ function tcbCreateEventHandler(event, tcb, scope, eventType) {
     eventParamType
   );
   addExpressionIdentifier(eventParam, ExpressionIdentifier.EVENT_PARAMETER);
-  return ts29.factory.createArrowFunction(
+  return ts30.factory.createArrowFunction(
     void 0,
     void 0,
     [eventParam],
-    ts29.factory.createKeywordTypeNode(ts29.SyntaxKind.AnyKeyword),
+    ts30.factory.createKeywordTypeNode(ts30.SyntaxKind.AnyKeyword),
     void 0,
-    ts29.factory.createBlock([body])
+    ts30.factory.createBlock([body])
   );
 }
 function tcbEventHandlerExpression(ast, tcb, scope) {
@@ -5630,7 +6786,7 @@ function isSplitTwoWayBinding(inputName, output, inputs, tcb) {
 var TcbEventHandlerTranslator = class extends TcbExpressionTranslator {
   resolve(ast) {
     if (ast instanceof PropertyRead4 && ast.receiver instanceof ImplicitReceiver3 && !(ast.receiver instanceof ThisReceiver) && ast.name === EVENT_PARAMETER) {
-      const event = ts29.factory.createIdentifier(EVENT_PARAMETER);
+      const event = ts30.factory.createIdentifier(EVENT_PARAMETER);
       addParseSpanInfo(event, ast.nameSpan);
       return event;
     }
@@ -5654,33 +6810,44 @@ var TcbForLoopTrackTranslator = class extends TcbExpressionTranslator {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_check_file.mjs
-import ts30 from "typescript";
+import ts31 from "typescript";
 var TypeCheckFile = class extends Environment {
   constructor(fileName, config, refEmitter, reflector, compilerHost) {
-    super(config, new ImportManager(new NoopImportRewriter(), "i"), refEmitter, reflector, ts30.createSourceFile(compilerHost.getCanonicalFileName(fileName), "", ts30.ScriptTarget.Latest, true));
+    super(config, new ImportManager({
+      forceGenerateNamespacesForNewImports: true,
+      shouldUseSingleQuotes: () => true
+    }), refEmitter, reflector, ts31.createSourceFile(compilerHost.getCanonicalFileName(fileName), "", ts31.ScriptTarget.Latest, true));
     this.fileName = fileName;
     this.nextTcbId = 1;
     this.tcbStatements = [];
   }
   addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
-    const fnId = ts30.factory.createIdentifier(`_tcb${this.nextTcbId++}`);
+    const fnId = ts31.factory.createIdentifier(`_tcb${this.nextTcbId++}`);
     const fn = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);
     this.tcbStatements.push(fn);
   }
   render(removeComments) {
     ensureTypeCheckFilePreparationImports(this);
-    let source = this.importManager.getAllImports(this.contextFile.fileName).map(getImportString).join("\n") + "\n\n";
-    const printer = ts30.createPrinter({ removeComments });
+    const importChanges = this.importManager.finalize();
+    if (importChanges.updatedImports.size > 0) {
+      throw new Error("AssertionError: Expected no imports to be updated for a new type check file.");
+    }
+    const printer = ts31.createPrinter({ removeComments });
+    let source = "";
+    const newImports = importChanges.newImports.get(this.contextFile.fileName);
+    if (newImports !== void 0) {
+      source += newImports.map((i) => printer.printNode(ts31.EmitHint.Unspecified, i, this.contextFile)).join("\n");
+    }
     source += "\n";
     for (const stmt of this.pipeInstStatements) {
-      source += printer.printNode(ts30.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
+      source += printer.printNode(ts31.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
     }
     for (const stmt of this.typeCtorStatements) {
-      source += printer.printNode(ts30.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
+      source += printer.printNode(ts31.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
     }
     source += "\n";
     for (const stmt of this.tcbStatements) {
-      source += printer.printNode(ts30.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
+      source += printer.printNode(ts31.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
     }
     source += "\nexport const IS_A_MODULE = true;\n";
     return source;
@@ -5793,18 +6960,44 @@ var TypeCheckContextImpl = class {
     if (!this.opMap.has(sf)) {
       return null;
     }
-    const importManager = new ImportManager(new NoopImportRewriter(), "_i");
-    const ops = this.opMap.get(sf).sort(orderOps);
-    const textParts = splitStringAtPoints(sf.text, ops.map((op) => op.splitPoint));
-    const printer = ts31.createPrinter({ omitTrailingSemicolon: true });
-    let code = textParts[0];
-    ops.forEach((op, idx) => {
-      const text = op.execute(importManager, sf, this.refEmitter, printer);
-      code += "\n\n" + text + textParts[idx + 1];
+    const printer = ts32.createPrinter({ omitTrailingSemicolon: true });
+    const importManager = new ImportManager({
+      forceGenerateNamespacesForNewImports: true,
+      shouldUseSingleQuotes: () => true
+    });
+    const updates = this.opMap.get(sf).map((op) => {
+      return {
+        pos: op.splitPoint,
+        text: op.execute(importManager, sf, this.refEmitter, printer)
+      };
     });
-    let imports = importManager.getAllImports(sf.fileName).map(getImportString).join("\n");
-    code = imports + "\n" + code;
-    return code;
+    const { newImports, updatedImports } = importManager.finalize();
+    if (newImports.has(sf.fileName)) {
+      newImports.get(sf.fileName).forEach((newImport) => {
+        updates.push({
+          pos: 0,
+          text: printer.printNode(ts32.EmitHint.Unspecified, newImport, sf)
+        });
+      });
+    }
+    for (const [oldBindings, newBindings] of updatedImports.entries()) {
+      if (oldBindings.getSourceFile() !== sf) {
+        throw new Error("Unexpected updates to unrelated source files.");
+      }
+      updates.push({
+        pos: oldBindings.getStart(),
+        deletePos: oldBindings.getEnd(),
+        text: printer.printNode(ts32.EmitHint.Unspecified, newBindings, sf)
+      });
+    }
+    const result = new MagicString(sf.text, { filename: sf.fileName });
+    for (const update of updates) {
+      if (update.deletePos !== void 0) {
+        result.remove(update.pos, update.deletePos);
+      }
+      result.appendLeft(update.pos, update.text);
+    }
+    return result.toString();
   }
   finalize() {
     const updates = /* @__PURE__ */ new Map();
@@ -5877,7 +7070,7 @@ var TypeCheckContextImpl = class {
       if (span.start.offset === span.end.offset) {
         span.end.offset++;
       }
-      return makeTemplateDiagnostic(templateId, sourceMapping, span, ts31.DiagnosticCategory.Error, ngErrorCode(ErrorCode.TEMPLATE_PARSE_ERROR), error.msg);
+      return makeTemplateDiagnostic(templateId, sourceMapping, span, ts32.DiagnosticCategory.Error, ngErrorCode(ErrorCode.TEMPLATE_PARSE_ERROR), error.msg);
     });
   }
 };
@@ -5895,9 +7088,9 @@ var InlineTcbOp = class {
   }
   execute(im, sf, refEmitter, printer) {
     const env = new Environment(this.config, im, refEmitter, this.reflector, sf);
-    const fnName = ts31.factory.createIdentifier(`_tcb_${this.ref.node.pos}`);
+    const fnName = ts32.factory.createIdentifier(`_tcb_${this.ref.node.pos}`);
     const fn = generateTypeCheckBlock(env, this.ref, fnName, this.meta, this.domSchemaChecker, this.oobRecorder, TcbGenericContextBehavior.CopyClassNodes);
-    return printer.printNode(ts31.EmitHint.Unspecified, fn, sf);
+    return printer.printNode(ts32.EmitHint.Unspecified, fn, sf);
   }
 };
 var TypeCtorOp = class {
@@ -5912,23 +7105,9 @@ var TypeCtorOp = class {
   execute(im, sf, refEmitter, printer) {
     const emitEnv = new ReferenceEmitEnvironment(im, refEmitter, this.reflector, sf);
     const tcb = generateInlineTypeCtor(emitEnv, this.ref.node, this.meta);
-    return printer.printNode(ts31.EmitHint.Unspecified, tcb, sf);
+    return printer.printNode(ts32.EmitHint.Unspecified, tcb, sf);
   }
 };
-function orderOps(op1, op2) {
-  return op1.splitPoint - op2.splitPoint;
-}
-function splitStringAtPoints(str, points) {
-  const splits = [];
-  let start = 0;
-  for (let i = 0; i < points.length; i++) {
-    const point = points[i];
-    splits.push(str.substring(start, point));
-    start = point;
-  }
-  splits.push(str.substring(start));
-  return splits;
-}
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/source.mjs
 import { ParseLocation, ParseSourceSpan } from "@angular/compiler";
@@ -6027,7 +7206,7 @@ var TemplateSourceManager = class {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/template_symbol_builder.mjs
 import { AST, ASTWithSource as ASTWithSource3, BindingPipe as BindingPipe2, PropertyRead as PropertyRead5, PropertyWrite as PropertyWrite4, R3Identifiers as R3Identifiers4, SafePropertyRead as SafePropertyRead4, TmplAstBoundAttribute as TmplAstBoundAttribute2, TmplAstBoundEvent, TmplAstElement as TmplAstElement4, TmplAstReference as TmplAstReference4, TmplAstTemplate as TmplAstTemplate3, TmplAstTextAttribute as TmplAstTextAttribute3, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
-import ts32 from "typescript";
+import ts33 from "typescript";
 var SymbolBuilder = class {
   constructor(tcbPath, tcbIsShim, typeCheckBlock, templateData, componentScopeReader, getTypeChecker) {
     this.tcbPath = tcbPath;
@@ -6071,7 +7250,7 @@ var SymbolBuilder = class {
   getSymbolOfElement(element) {
     var _a;
     const elementSourceSpan = (_a = element.startSourceSpan) != null ? _a : element.sourceSpan;
-    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: elementSourceSpan, filter: ts32.isVariableDeclaration });
+    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: elementSourceSpan, filter: ts33.isVariableDeclaration });
     if (node === null) {
       return null;
     }
@@ -6091,12 +7270,12 @@ var SymbolBuilder = class {
     var _a;
     const elementSourceSpan = (_a = element.startSourceSpan) != null ? _a : element.sourceSpan;
     const tcbSourceFile = this.typeCheckBlock.getSourceFile();
-    const isDirectiveDeclaration = (node) => (ts32.isTypeNode(node) || ts32.isIdentifier(node)) && ts32.isVariableDeclaration(node.parent) && hasExpressionIdentifier(tcbSourceFile, node, ExpressionIdentifier.DIRECTIVE);
+    const isDirectiveDeclaration = (node) => (ts33.isTypeNode(node) || ts33.isIdentifier(node)) && ts33.isVariableDeclaration(node.parent) && hasExpressionIdentifier(tcbSourceFile, node, ExpressionIdentifier.DIRECTIVE);
     const nodes = findAllMatchingNodes(this.typeCheckBlock, { withSpan: elementSourceSpan, filter: isDirectiveDeclaration });
     const symbols = [];
     for (const node of nodes) {
       const symbol = this.getSymbolOfTsNode(node.parent);
-      if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !ts32.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
+      if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !ts33.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
         continue;
       }
       const meta = this.getDirectiveMeta(element, symbol.tsSymbol.valueDeclaration);
@@ -6127,7 +7306,7 @@ var SymbolBuilder = class {
       if (!isHostDirectiveMetaForGlobalMode(current)) {
         throw new Error("Impossible state: typecheck code path in local compilation mode.");
       }
-      if (!ts32.isClassDeclaration(current.directive.node)) {
+      if (!ts33.isClassDeclaration(current.directive.node)) {
         continue;
       }
       const symbol = this.getSymbolOfTsNode(current.directive.node);
@@ -6196,21 +7375,21 @@ var SymbolBuilder = class {
       }
       expectedAccess = bindingPropertyNames[0].classPropertyName;
     }
-    function filter(n) {
-      if (!isAccessExpression(n)) {
+    function filter(n2) {
+      if (!isAccessExpression(n2)) {
         return false;
       }
-      if (ts32.isPropertyAccessExpression(n)) {
-        return n.name.getText() === expectedAccess;
+      if (ts33.isPropertyAccessExpression(n2)) {
+        return n2.name.getText() === expectedAccess;
       } else {
-        return ts32.isStringLiteral(n.argumentExpression) && n.argumentExpression.text === expectedAccess;
+        return ts33.isStringLiteral(n2.argumentExpression) && n2.argumentExpression.text === expectedAccess;
       }
     }
     const outputFieldAccesses = findAllMatchingNodes(this.typeCheckBlock, { withSpan: eventBinding.keySpan, filter });
     const bindings = [];
     for (const outputFieldAccess of outputFieldAccesses) {
       if (consumer instanceof TmplAstTemplate3 || consumer instanceof TmplAstElement4) {
-        if (!ts32.isPropertyAccessExpression(outputFieldAccess)) {
+        if (!ts33.isPropertyAccessExpression(outputFieldAccess)) {
           continue;
         }
         const addEventListener = outputFieldAccess.name;
@@ -6233,7 +7412,7 @@ var SymbolBuilder = class {
           }
         });
       } else {
-        if (!ts32.isElementAccessExpression(outputFieldAccess)) {
+        if (!ts33.isElementAccessExpression(outputFieldAccess)) {
           continue;
         }
         const tsSymbol = this.getTypeChecker().getSymbolAtLocation(outputFieldAccess.argumentExpression);
@@ -6319,7 +7498,7 @@ var SymbolBuilder = class {
       return null;
     }
     const [declaration] = tsSymbol.declarations;
-    if (!ts32.isVariableDeclaration(declaration) || !hasExpressionIdentifier(
+    if (!ts33.isVariableDeclaration(declaration) || !hasExpressionIdentifier(
       declaration.getSourceFile(),
       (_a = declaration.type) != null ? _a : declaration.name,
       ExpressionIdentifier.DIRECTIVE
@@ -6327,7 +7506,7 @@ var SymbolBuilder = class {
       return null;
     }
     const symbol = this.getSymbolOfTsNode(declaration);
-    if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !ts32.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
+    if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !ts33.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
       return null;
     }
     const ref = new Reference(symbol.tsSymbol.valueDeclaration);
@@ -6347,12 +7526,12 @@ var SymbolBuilder = class {
     };
   }
   getSymbolOfVariable(variable) {
-    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: variable.sourceSpan, filter: ts32.isVariableDeclaration });
+    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: variable.sourceSpan, filter: ts33.isVariableDeclaration });
     if (node === null) {
       return null;
     }
     let nodeValueSymbol = null;
-    if (ts32.isForOfStatement(node.parent.parent)) {
+    if (ts33.isForOfStatement(node.parent.parent)) {
       nodeValueSymbol = this.getSymbolOfTsNode(node);
     } else if (node.initializer !== void 0) {
       nodeValueSymbol = this.getSymbolOfTsNode(node.initializer);
@@ -6375,11 +7554,11 @@ var SymbolBuilder = class {
   }
   getSymbolOfReference(ref) {
     const target = this.templateData.boundTarget.getReferenceTarget(ref);
-    let node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: ref.sourceSpan, filter: ts32.isVariableDeclaration });
+    let node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: ref.sourceSpan, filter: ts33.isVariableDeclaration });
     if (node === null || target === null || node.initializer === void 0) {
       return null;
     }
-    const originalDeclaration = ts32.isParenthesizedExpression(node.initializer) && ts32.isAsExpression(node.initializer.expression) ? this.getTypeChecker().getSymbolAtLocation(node.name) : this.getTypeChecker().getSymbolAtLocation(node.initializer);
+    const originalDeclaration = ts33.isParenthesizedExpression(node.initializer) && ts33.isAsExpression(node.initializer.expression) ? this.getTypeChecker().getSymbolAtLocation(node.name) : this.getTypeChecker().getSymbolAtLocation(node.initializer);
     if (originalDeclaration === void 0 || originalDeclaration.valueDeclaration === void 0) {
       return null;
     }
@@ -6403,7 +7582,7 @@ var SymbolBuilder = class {
         referenceVarLocation: referenceVarTcbLocation
       };
     } else {
-      if (!ts32.isClassDeclaration(target.directive.ref.node)) {
+      if (!ts33.isClassDeclaration(target.directive.ref.node)) {
         return null;
       }
       return {
@@ -6418,7 +7597,7 @@ var SymbolBuilder = class {
     }
   }
   getSymbolOfPipe(expression) {
-    const methodAccess = findFirstMatchingNode(this.typeCheckBlock, { withSpan: expression.nameSpan, filter: ts32.isPropertyAccessExpression });
+    const methodAccess = findFirstMatchingNode(this.typeCheckBlock, { withSpan: expression.nameSpan, filter: ts33.isPropertyAccessExpression });
     if (methodAccess === null) {
       return null;
     }
@@ -6458,7 +7637,7 @@ var SymbolBuilder = class {
     }
     let node = null;
     if (expression instanceof PropertyRead5) {
-      node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: ts32.isPropertyAccessExpression });
+      node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: ts33.isPropertyAccessExpression });
     }
     if (node === null) {
       node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: anyNodeFilter });
@@ -6466,10 +7645,10 @@ var SymbolBuilder = class {
     if (node === null) {
       return null;
     }
-    while (ts32.isParenthesizedExpression(node)) {
+    while (ts33.isParenthesizedExpression(node)) {
       node = node.expression;
     }
-    if (expression instanceof SafePropertyRead4 && ts32.isConditionalExpression(node)) {
+    if (expression instanceof SafePropertyRead4 && ts33.isConditionalExpression(node)) {
       const whenTrueSymbol = this.getSymbolOfTsNode(node.whenTrue);
       if (whenTrueSymbol === null) {
         return null;
@@ -6486,11 +7665,11 @@ var SymbolBuilder = class {
   }
   getSymbolOfTsNode(node) {
     var _a;
-    while (ts32.isParenthesizedExpression(node)) {
+    while (ts33.isParenthesizedExpression(node)) {
       node = node.expression;
     }
     let tsSymbol;
-    if (ts32.isPropertyAccessExpression(node)) {
+    if (ts33.isPropertyAccessExpression(node)) {
       tsSymbol = this.getTypeChecker().getSymbolAtLocation(node.name);
     } else {
       tsSymbol = this.getTypeChecker().getSymbolAtLocation(node);
@@ -6508,33 +7687,33 @@ var SymbolBuilder = class {
     };
   }
   getTcbPositionForNode(node) {
-    if (ts32.isTypeReferenceNode(node)) {
+    if (ts33.isTypeReferenceNode(node)) {
       return this.getTcbPositionForNode(node.typeName);
-    } else if (ts32.isQualifiedName(node)) {
+    } else if (ts33.isQualifiedName(node)) {
       return node.right.getStart();
-    } else if (ts32.isPropertyAccessExpression(node)) {
+    } else if (ts33.isPropertyAccessExpression(node)) {
       return node.name.getStart();
-    } else if (ts32.isElementAccessExpression(node)) {
+    } else if (ts33.isElementAccessExpression(node)) {
       return node.argumentExpression.getStart();
     } else {
       return node.getStart();
     }
   }
 };
-function anyNodeFilter(n) {
+function anyNodeFilter(n2) {
   return true;
 }
 function sourceSpanEqual(a, b) {
   return a.start.offset === b.start.offset && a.end.offset === b.end.offset;
 }
 function unwrapSignalInputWriteTAccessor(expr) {
-  if (!ts32.isElementAccessExpression(expr) || !ts32.isPropertyAccessExpression(expr.argumentExpression)) {
+  if (!ts33.isElementAccessExpression(expr) || !ts33.isPropertyAccessExpression(expr.argumentExpression)) {
     return null;
   }
-  if (!ts32.isIdentifier(expr.argumentExpression.name) || expr.argumentExpression.name.text !== R3Identifiers4.InputSignalBrandWriteType.name) {
+  if (!ts33.isIdentifier(expr.argumentExpression.name) || expr.argumentExpression.name.text !== R3Identifiers4.InputSignalBrandWriteType.name) {
     return null;
   }
-  if (!ts32.isPropertyAccessExpression(expr.expression) && !ts32.isElementAccessExpression(expr.expression)) {
+  if (!ts33.isPropertyAccessExpression(expr.expression) && !ts33.isElementAccessExpression(expr.expression)) {
     throw new Error("Unexpected expression for signal input write type.");
   }
   return {
@@ -7248,7 +8427,7 @@ var SingleShimTypeCheckingHost = class extends SingleFileTypeCheckingHost {
 import { Interpolation, PropertyRead as PropertyRead6 } from "@angular/compiler";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/symbol_util.mjs
-import ts33 from "typescript";
+import ts34 from "typescript";
 var SIGNAL_FNS = /* @__PURE__ */ new Set([
   "WritableSignal",
   "Signal",
@@ -7263,7 +8442,7 @@ function isSignalSymbol(symbol) {
   const declarations = symbol.getDeclarations();
   return declarations !== void 0 && declarations.some((decl) => {
     const fileName = decl.getSourceFile().fileName;
-    return (ts33.isInterfaceDeclaration(decl) || ts33.isTypeAliasDeclaration(decl)) && SIGNAL_FNS.has(decl.name.text) && (fileName.includes("@angular/core") || fileName.includes("angular2/rc/packages/core"));
+    return (ts34.isInterfaceDeclaration(decl) || ts34.isTypeAliasDeclaration(decl)) && SIGNAL_FNS.has(decl.name.text) && (fileName.includes("@angular/core") || fileName.includes("angular2/rc/packages/core"));
   });
 }
 
@@ -7541,7 +8720,7 @@ var factory4 = {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable/index.mjs
 import { Binary } from "@angular/compiler";
-import ts34 from "typescript";
+import ts35 from "typescript";
 var NullishCoalescingNotNullableCheck = class extends TemplateCheckWithVisitor {
   constructor() {
     super(...arguments);
@@ -7555,7 +8734,7 @@ var NullishCoalescingNotNullableCheck = class extends TemplateCheckWithVisitor {
       return [];
     }
     const typeLeft = symbolLeft.tsType;
-    if (typeLeft.flags & (ts34.TypeFlags.Any | ts34.TypeFlags.Unknown)) {
+    if (typeLeft.flags & (ts35.TypeFlags.Any | ts35.TypeFlags.Unknown)) {
       return [];
     }
     if (typeLeft.getNonNullableType() !== typeLeft)
@@ -7586,7 +8765,7 @@ var factory5 = {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/extended/checks/optional_chain_not_nullable/index.mjs
 import { SafeCall as SafeCall2, SafeKeyedRead as SafeKeyedRead2, SafePropertyRead as SafePropertyRead5 } from "@angular/compiler";
-import ts35 from "typescript";
+import ts36 from "typescript";
 var OptionalChainNotNullableCheck = class extends TemplateCheckWithVisitor {
   constructor() {
     super(...arguments);
@@ -7600,7 +8779,7 @@ var OptionalChainNotNullableCheck = class extends TemplateCheckWithVisitor {
       return [];
     }
     const typeLeft = symbolLeft.tsType;
-    if (typeLeft.flags & (ts35.TypeFlags.Any | ts35.TypeFlags.Unknown)) {
+    if (typeLeft.flags & (ts36.TypeFlags.Any | ts36.TypeFlags.Unknown)) {
       return [];
     }
     if (typeLeft.getNonNullableType() !== typeLeft)
@@ -7694,7 +8873,7 @@ var factory8 = {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker.mjs
-import ts36 from "typescript";
+import ts37 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/api/src/public_options.mjs
 var DiagnosticCategoryLabel;
@@ -7743,9 +8922,9 @@ var ExtendedTemplateCheckerImpl = class {
 function diagnosticLabelToCategory(label) {
   switch (label) {
     case DiagnosticCategoryLabel.Warning:
-      return ts36.DiagnosticCategory.Warning;
+      return ts37.DiagnosticCategory.Warning;
     case DiagnosticCategoryLabel.Error:
-      return ts36.DiagnosticCategory.Error;
+      return ts37.DiagnosticCategory.Error;
     case DiagnosticCategoryLabel.Suppress:
       return null;
     default:
@@ -7775,7 +8954,7 @@ var SUPPORTED_DIAGNOSTIC_NAMES = /* @__PURE__ */ new Set([
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/template_semantics/src/template_semantics_checker.mjs
 import { ASTWithSource as ASTWithSource5, ImplicitReceiver as ImplicitReceiver4, RecursiveAstVisitor as RecursiveAstVisitor3, TmplAstBoundEvent as TmplAstBoundEvent3, TmplAstRecursiveVisitor as TmplAstRecursiveVisitor2, TmplAstVariable as TmplAstVariable3 } from "@angular/compiler";
-import ts37 from "typescript";
+import ts38 from "typescript";
 var TemplateSemanticsCheckerImpl = class {
   constructor(templateTypeChecker) {
     this.templateTypeChecker = templateTypeChecker;
@@ -7843,7 +9022,7 @@ var ExpressionsSemanticsVisitor = class extends RecursiveAstVisitor3 {
   }
   makeIllegalTemplateVarDiagnostic(target, expressionNode, errorMessage) {
     var _a, _b;
-    return this.templateTypeChecker.makeTemplateDiagnostic(this.component, expressionNode.handlerSpan, ts37.DiagnosticCategory.Error, ngErrorCode(ErrorCode.WRITE_TO_READ_ONLY_VARIABLE), errorMessage, [{
+    return this.templateTypeChecker.makeTemplateDiagnostic(this.component, expressionNode.handlerSpan, ts38.DiagnosticCategory.Error, ngErrorCode(ErrorCode.WRITE_TO_READ_ONLY_VARIABLE), errorMessage, [{
       text: `The variable ${target.name} is declared here.`,
       start: ((_a = target.valueSpan) == null ? void 0 : _a.start.offset) || target.sourceSpan.start.offset,
       end: ((_b = target.valueSpan) == null ? void 0 : _b.end.offset) || target.sourceSpan.end.offset,
@@ -7976,7 +9155,7 @@ var NgCompiler = class {
     this.currentProgram = inputProgram;
     this.closureCompilerEnabled = !!this.options.annotateForClosureCompiler;
     this.entryPoint = adapter.entryPoint !== null ? getSourceFileOrNull(inputProgram, adapter.entryPoint) : null;
-    const moduleResolutionCache = ts38.createModuleResolutionCache(
+    const moduleResolutionCache = ts39.createModuleResolutionCache(
       this.adapter.getCurrentDirectory(),
       this.adapter.getCanonicalFileName.bind(this.adapter)
     );
@@ -8020,7 +9199,7 @@ var NgCompiler = class {
       }
       for (const clazz of classesToUpdate) {
         this.compilation.traitCompiler.updateResources(clazz);
-        if (!ts38.isClassDeclaration(clazz)) {
+        if (!ts39.isClassDeclaration(clazz)) {
           continue;
         }
         this.compilation.templateTypeChecker.invalidateClass(clazz);
@@ -8514,18 +9693,18 @@ function isAngularCorePackage(program) {
     return false;
   }
   return r3Symbols.statements.some((stmt) => {
-    if (!ts38.isVariableStatement(stmt)) {
+    if (!ts39.isVariableStatement(stmt)) {
       return false;
     }
-    const modifiers = ts38.getModifiers(stmt);
-    if (modifiers === void 0 || !modifiers.some((mod) => mod.kind === ts38.SyntaxKind.ExportKeyword)) {
+    const modifiers = ts39.getModifiers(stmt);
+    if (modifiers === void 0 || !modifiers.some((mod) => mod.kind === ts39.SyntaxKind.ExportKeyword)) {
       return false;
     }
     return stmt.declarationList.declarations.some((decl) => {
-      if (!ts38.isIdentifier(decl.name) || decl.name.text !== "ITS_JUST_ANGULAR") {
+      if (!ts39.isIdentifier(decl.name) || decl.name.text !== "ITS_JUST_ANGULAR") {
         return false;
       }
-      if (decl.initializer === void 0 || decl.initializer.kind !== ts38.SyntaxKind.TrueKeyword) {
+      if (decl.initializer === void 0 || decl.initializer.kind !== ts39.SyntaxKind.TrueKeyword) {
         return false;
       }
       return true;
@@ -8539,7 +9718,7 @@ function* verifyCompatibleTypeCheckOptions(options) {
   var _a, _b, _c;
   if (options.fullTemplateTypeCheck === false && options.strictTemplates === true) {
     yield makeConfigDiagnostic({
-      category: ts38.DiagnosticCategory.Error,
+      category: ts39.DiagnosticCategory.Error,
       code: ErrorCode.CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK,
       messageText: `
 Angular compiler option "strictTemplates" is enabled, however "fullTemplateTypeCheck" is disabled.
@@ -8558,7 +9737,7 @@ https://angular.io/guide/template-typecheck
   }
   if (options.extendedDiagnostics && options.strictTemplates === false) {
     yield makeConfigDiagnostic({
-      category: ts38.DiagnosticCategory.Error,
+      category: ts39.DiagnosticCategory.Error,
       code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES,
       messageText: `
 Angular compiler option "extendedDiagnostics" is configured, however "strictTemplates" is disabled.
@@ -8575,7 +9754,7 @@ One of the following actions is required:
   const defaultCategory = (_a = options.extendedDiagnostics) == null ? void 0 : _a.defaultCategory;
   if (defaultCategory && !allowedCategoryLabels.includes(defaultCategory)) {
     yield makeConfigDiagnostic({
-      category: ts38.DiagnosticCategory.Error,
+      category: ts39.DiagnosticCategory.Error,
       code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL,
       messageText: `
 Angular compiler option "extendedDiagnostics.defaultCategory" has an unknown diagnostic category: "${defaultCategory}".
@@ -8588,7 +9767,7 @@ ${allowedCategoryLabels.join("\n")}
   for (const [checkName, category] of Object.entries((_c = (_b = options.extendedDiagnostics) == null ? void 0 : _b.checks) != null ? _c : {})) {
     if (!SUPPORTED_DIAGNOSTIC_NAMES.has(checkName)) {
       yield makeConfigDiagnostic({
-        category: ts38.DiagnosticCategory.Error,
+        category: ts39.DiagnosticCategory.Error,
         code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK,
         messageText: `
 Angular compiler option "extendedDiagnostics.checks" has an unknown check: "${checkName}".
@@ -8600,7 +9779,7 @@ ${Array.from(SUPPORTED_DIAGNOSTIC_NAMES).join("\n")}
     }
     if (!allowedCategoryLabels.includes(category)) {
       yield makeConfigDiagnostic({
-        category: ts38.DiagnosticCategory.Error,
+        category: ts39.DiagnosticCategory.Error,
         code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL,
         messageText: `
 Angular compiler option "extendedDiagnostics.checks['${checkName}']" has an unknown diagnostic category: "${category}".
@@ -8630,7 +9809,7 @@ var ReferenceGraphAdapter = class {
     for (const { node } of references) {
       let sourceFile = node.getSourceFile();
       if (sourceFile === void 0) {
-        sourceFile = ts38.getOriginalNode(node).getSourceFile();
+        sourceFile = ts39.getOriginalNode(node).getSourceFile();
       }
       if (sourceFile === void 0 || !isDtsPath(sourceFile.fileName)) {
         this.graph.add(source, node);
@@ -8669,7 +9848,7 @@ function versionMapFromProgram(program, driver) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/src/host.mjs
-import ts39 from "typescript";
+import ts40 from "typescript";
 var DelegatingCompilerHost2 = class {
   get jsDocParsingMode() {
     return this.delegate.jsDocParsingMode;
@@ -8754,7 +9933,7 @@ var NgCompilerHost = class extends DelegatingCompilerHost2 {
       entryPoint = findFlatIndexEntryPoint(normalizedTsInputFiles);
       if (entryPoint === null) {
         diagnostics.push({
-          category: ts39.DiagnosticCategory.Error,
+          category: ts40.DiagnosticCategory.Error,
           code: ngErrorCode(ErrorCode.CONFIG_FLAT_MODULE_NO_INDEX),
           file: void 0,
           start: void 0,
@@ -8797,10 +9976,10 @@ var NgCompilerHost = class extends DelegatingCompilerHost2 {
     return this.fileNameToModuleName !== void 0 ? this : null;
   }
   createCachedResolveModuleNamesFunction() {
-    const moduleResolutionCache = ts39.createModuleResolutionCache(this.getCurrentDirectory(), this.getCanonicalFileName.bind(this));
+    const moduleResolutionCache = ts40.createModuleResolutionCache(this.getCurrentDirectory(), this.getCanonicalFileName.bind(this));
     return (moduleNames, containingFile, reusedNames, redirectedReference, options) => {
       return moduleNames.map((moduleName) => {
-        const module = ts39.resolveModuleName(moduleName, containingFile, options, this, moduleResolutionCache, redirectedReference);
+        const module = ts40.resolveModuleName(moduleName, containingFile, options, this, moduleResolutionCache, redirectedReference);
         return module.resolvedModule;
       });
     };
@@ -8824,7 +10003,7 @@ var NgtscProgram = class {
     if (reuseProgram !== void 0) {
       retagAllTsFiles(reuseProgram);
     }
-    this.tsProgram = perfRecorder.inPhase(PerfPhase.TypeScriptProgramCreate, () => ts40.createProgram(this.host.inputFiles, options, this.host, reuseProgram));
+    this.tsProgram = perfRecorder.inPhase(PerfPhase.TypeScriptProgramCreate, () => ts41.createProgram(this.host.inputFiles, options, this.host, reuseProgram));
     perfRecorder.phase(PerfPhase.Unaccounted);
     perfRecorder.memory(PerfCheckpoint.TypeScriptProgramCreate);
     this.host.postProgramCreationCleanup();
@@ -9040,16 +10219,16 @@ function createProgram({ rootNames, options, host, oldProgram }) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/perform_compile.mjs
-import ts42 from "typescript";
+import ts43 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/util.mjs
-import ts41 from "typescript";
+import ts42 from "typescript";
 function createMessageDiagnostic(messageText) {
   return {
     file: void 0,
     start: void 0,
     length: void 0,
-    category: ts41.DiagnosticCategory.Message,
+    category: ts42.DiagnosticCategory.Message,
     messageText,
     code: DEFAULT_ERROR_CODE,
     source: SOURCE
@@ -9058,13 +10237,13 @@ function createMessageDiagnostic(messageText) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/perform_compile.mjs
 var defaultFormatHost = {
-  getCurrentDirectory: () => ts42.sys.getCurrentDirectory(),
+  getCurrentDirectory: () => ts43.sys.getCurrentDirectory(),
   getCanonicalFileName: (fileName) => fileName,
-  getNewLine: () => ts42.sys.newLine
+  getNewLine: () => ts43.sys.newLine
 };
 function formatDiagnostics(diags, host = defaultFormatHost) {
   if (diags && diags.length) {
-    return diags.map((diagnostic) => replaceTsWithNgInErrors(ts42.formatDiagnosticsWithColorAndContext([diagnostic], host))).join("");
+    return diags.map((diagnostic) => replaceTsWithNgInErrors(ts43.formatDiagnosticsWithColorAndContext([diagnostic], host))).join("");
   } else {
     return "";
   }
@@ -9081,7 +10260,7 @@ function readConfiguration(project, existingOptions, host = getFileSystem()) {
   var _a;
   try {
     const fs = getFileSystem();
-    const readConfigFile = (configFile) => ts42.readConfigFile(configFile, (file) => host.readFile(host.resolve(file)));
+    const readConfigFile = (configFile) => ts43.readConfigFile(configFile, (file) => host.readFile(host.resolve(file)));
     const readAngularCompilerOptions = (configFile, parentOptions = {}) => {
       const { config: config2, error: error2 } = readConfigFile(configFile);
       if (error2) {
@@ -9116,7 +10295,7 @@ function readConfiguration(project, existingOptions, host = getFileSystem()) {
       ...existingOptions
     };
     const parseConfigHost = createParseConfigHost(host, fs);
-    const { options, errors, fileNames: rootNames, projectReferences } = ts42.parseJsonConfigFileContent(config, parseConfigHost, basePath, existingCompilerOptions, configFileName);
+    const { options, errors, fileNames: rootNames, projectReferences } = ts43.parseJsonConfigFileContent(config, parseConfigHost, basePath, existingCompilerOptions, configFileName);
     let emitFlags = EmitFlags.Default;
     if (!(options["skipMetadataEmit"] || options["flatModuleOutFile"])) {
       emitFlags |= EmitFlags.Metadata;
@@ -9127,7 +10306,7 @@ function readConfiguration(project, existingOptions, host = getFileSystem()) {
     return { project: projectFile, rootNames, projectReferences, options, errors, emitFlags };
   } catch (e) {
     const errors = [{
-      category: ts42.DiagnosticCategory.Error,
+      category: ts43.DiagnosticCategory.Error,
       messageText: (_a = e.stack) != null ? _a : e.message,
       file: void 0,
       start: void 0,
@@ -9141,7 +10320,7 @@ function readConfiguration(project, existingOptions, host = getFileSystem()) {
 function createParseConfigHost(host, fs = getFileSystem()) {
   return {
     fileExists: host.exists.bind(host),
-    readDirectory: ts42.sys.readDirectory,
+    readDirectory: ts43.sys.readDirectory,
     readFile: host.readFile.bind(host),
     useCaseSensitiveFileNames: fs.isCaseSensitive()
   };
@@ -9161,7 +10340,7 @@ function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
     }
   } else {
     const parseConfigHost = createParseConfigHost(host, fs);
-    const { resolvedModule } = ts42.nodeModuleNameResolver(extendsValue, configFile, { moduleResolution: ts42.ModuleResolutionKind.Node10, resolveJsonModule: true }, parseConfigHost);
+    const { resolvedModule } = ts43.nodeModuleNameResolver(extendsValue, configFile, { moduleResolution: ts43.ModuleResolutionKind.Node10, resolveJsonModule: true }, parseConfigHost);
     if (resolvedModule) {
       return absoluteFrom(resolvedModule.resolvedFileName);
     }
@@ -9171,7 +10350,7 @@ function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
 function exitCodeFromResult(diags) {
   if (!diags)
     return 0;
-  if (diags.every((diag) => diag.category !== ts42.DiagnosticCategory.Error)) {
+  if (diags.every((diag) => diag.category !== ts43.DiagnosticCategory.Error)) {
     return 0;
   }
   return diags.some((d) => d.source === "angular" && d.code === UNKNOWN_ERROR_CODE) ? 2 : 1;
@@ -9204,7 +10383,7 @@ function performCompilation({ rootNames, options, host, oldProgram, emitCallback
   } catch (e) {
     program = void 0;
     allDiagnostics.push({
-      category: ts42.DiagnosticCategory.Error,
+      category: ts43.DiagnosticCategory.Error,
       messageText: (_a = e.stack) != null ? _a : e.message,
       code: UNKNOWN_ERROR_CODE,
       file: void 0,
@@ -9231,7 +10410,7 @@ function defaultGatherDiagnostics(program) {
   return allDiagnostics;
 }
 function hasErrors(diags) {
-  return diags.some((d) => d.category === ts42.DiagnosticCategory.Error);
+  return diags.some((d) => d.category === ts43.DiagnosticCategory.Error);
 }
 
 export {
@@ -9245,6 +10424,7 @@ export {
   MemberType,
   DecoratorType,
   MemberTags,
+  DocsExtractor,
   untagAllTsFiles,
   TsCreateProgramDriver,
   PatchedProgramIncrementalBuildStrategy,
@@ -9276,4 +10456,4 @@ export {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-//# sourceMappingURL=chunk-VH6EDOMC.js.map
+//# sourceMappingURL=chunk-LHQ7WPU2.js.map