@angular/compiler-cli 17.3.1 → 17.3.3

package/bundles/{chunk-6X7GQ6BQ.js → chunk-XZRJJDCL.js}

@@ -12,12 +12,12 @@ import {
   resolve,
   stripExtension,
   toRelativeImport
-} from "./chunk-75YFKYUJ.js";
+} from "./chunk-UM6JO3VZ.js";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
 import ts from "typescript";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_code.mjs
 var ErrorCode;
 (function(ErrorCode2) {
   ErrorCode2[ErrorCode2["DECORATOR_ARG_NOT_LITERAL"] = 1001] = "DECORATOR_ARG_NOT_LITERAL";
@@ -30,6 +30,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["INITIALIZER_API_WITH_DISALLOWED_DECORATOR"] = 1050] = "INITIALIZER_API_WITH_DISALLOWED_DECORATOR";
   ErrorCode2[ErrorCode2["INITIALIZER_API_DECORATOR_METADATA_COLLISION"] = 1051] = "INITIALIZER_API_DECORATOR_METADATA_COLLISION";
   ErrorCode2[ErrorCode2["INITIALIZER_API_NO_REQUIRED_FUNCTION"] = 1052] = "INITIALIZER_API_NO_REQUIRED_FUNCTION";
+  ErrorCode2[ErrorCode2["INITIALIZER_API_DISALLOWED_MEMBER_VISIBILITY"] = 1053] = "INITIALIZER_API_DISALLOWED_MEMBER_VISIBILITY";
   ErrorCode2[ErrorCode2["INCORRECTLY_DECLARED_ON_STATIC_MEMBER"] = 1100] = "INCORRECTLY_DECLARED_ON_STATIC_MEMBER";
   ErrorCode2[ErrorCode2["COMPONENT_MISSING_TEMPLATE"] = 2001] = "COMPONENT_MISSING_TEMPLATE";
   ErrorCode2[ErrorCode2["PIPE_MISSING_NAME"] = 2002] = "PIPE_MISSING_NAME";
@@ -105,7 +106,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION"] = 11003] = "LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION";
 })(ErrorCode || (ErrorCode = {}));
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/util.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/util.mjs
 var ERROR_CODE_MATCHER = /(\u001b\[\d+m ?)TS-99(\d+: ?\u001b\[\d+m)/g;
 function replaceTsWithNgInErrors(errors) {
   return errors.replace(ERROR_CODE_MATCHER, "$1NG$2");
@@ -114,15 +115,15 @@ function ngErrorCode(code) {
   return parseInt("-99" + code);
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
 var FatalDiagnosticError = class extends Error {
   constructor(code, node, diagnosticMessage, relatedInformation) {
-    super(`FatalDiagnosticError #${code}: ${diagnosticMessage}`);
+    super(`FatalDiagnosticError: Code: ${code}, Message: ${ts.flattenDiagnosticMessageText(diagnosticMessage, "\n")}`);
     this.code = code;
     this.node = node;
     this.diagnosticMessage = diagnosticMessage;
     this.relatedInformation = relatedInformation;
-    this.message = null;
+    this.message = this.message;
     this._isFatalDiagnosticError = true;
     Object.setPrototypeOf(this, new.target.prototype);
   }
@@ -179,7 +180,7 @@ function isLocalCompilationDiagnostics(diagnostic) {
   return diagnostic.code === ngErrorCode(ErrorCode.LOCAL_COMPILATION_UNRESOLVED_CONST) || diagnostic.code === ngErrorCode(ErrorCode.LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION);
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/docs.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/docs.mjs
 var COMPILER_ERRORS_WITH_GUIDES = /* @__PURE__ */ new Set([
   ErrorCode.DECORATOR_ARG_NOT_LITERAL,
   ErrorCode.IMPORT_CYCLE_DETECTED,
@@ -191,10 +192,10 @@ var COMPILER_ERRORS_WITH_GUIDES = /* @__PURE__ */ new Set([
   ErrorCode.WARN_NGMODULE_ID_UNNECESSARY
 ]);
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.mjs
 var ERROR_DETAILS_PAGE_BASE_URL = "https://angular.io/errors";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.mjs
 var ExtendedTemplateDiagnosticName;
 (function(ExtendedTemplateDiagnosticName2) {
   ExtendedTemplateDiagnosticName2["INVALID_BANANA_IN_BOX"] = "invalidBananaInBox";
@@ -209,10 +210,10 @@ var ExtendedTemplateDiagnosticName;
   ExtendedTemplateDiagnosticName2["CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION"] = "controlFlowPreventingContentProjection";
 })(ExtendedTemplateDiagnosticName || (ExtendedTemplateDiagnosticName = {}));
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
 import ts5 from "typescript";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/host.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/host.mjs
 import ts2 from "typescript";
 function isDecoratorIdentifier(exp) {
   return ts2.isIdentifier(exp) || ts2.isPropertyAccessExpression(exp) && ts2.isIdentifier(exp.expression) && ts2.isIdentifier(exp.name);
@@ -225,9 +226,17 @@ var ClassMemberKind;
   ClassMemberKind2[ClassMemberKind2["Property"] = 3] = "Property";
   ClassMemberKind2[ClassMemberKind2["Method"] = 4] = "Method";
 })(ClassMemberKind || (ClassMemberKind = {}));
+var ClassMemberAccessLevel;
+(function(ClassMemberAccessLevel2) {
+  ClassMemberAccessLevel2[ClassMemberAccessLevel2["PublicWritable"] = 0] = "PublicWritable";
+  ClassMemberAccessLevel2[ClassMemberAccessLevel2["PublicReadonly"] = 1] = "PublicReadonly";
+  ClassMemberAccessLevel2[ClassMemberAccessLevel2["Protected"] = 2] = "Protected";
+  ClassMemberAccessLevel2[ClassMemberAccessLevel2["Private"] = 3] = "Private";
+  ClassMemberAccessLevel2[ClassMemberAccessLevel2["EcmaScriptPrivate"] = 4] = "EcmaScriptPrivate";
+})(ClassMemberAccessLevel || (ClassMemberAccessLevel = {}));
 var AmbientImport = {};
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/type_to_value.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/type_to_value.mjs
 import ts3 from "typescript";
 function typeToValue(typeNode, checker, isLocalCompilation) {
   var _a, _b;
@@ -400,7 +409,7 @@ function extractModuleName(node) {
   return node.moduleSpecifier.text;
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/util.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/util.mjs
 import ts4 from "typescript";
 function isNamedClassDeclaration(node) {
   return ts4.isClassDeclaration(node) && isIdentifier(node.name);
@@ -408,8 +417,23 @@ function isNamedClassDeclaration(node) {
 function isIdentifier(node) {
   return node !== void 0 && ts4.isIdentifier(node);
 }
+function classMemberAccessLevelToString(level) {
+  switch (level) {
+    case ClassMemberAccessLevel.EcmaScriptPrivate:
+      return "ES private";
+    case ClassMemberAccessLevel.Private:
+      return "private";
+    case ClassMemberAccessLevel.Protected:
+      return "protected";
+    case ClassMemberAccessLevel.PublicReadonly:
+      return "public readonly";
+    case ClassMemberAccessLevel.PublicWritable:
+    default:
+      return "public";
+  }
+}
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
 var TypeScriptReflectionHost = class {
   constructor(checker, isLocalCompilation = false) {
     this.checker = checker;
@@ -421,7 +445,16 @@ var TypeScriptReflectionHost = class {
   }
   getMembersOfClass(clazz) {
     const tsClazz = castDeclarationToClassOrDie(clazz);
-    return tsClazz.members.map((member) => this._reflectMember(member)).filter((member) => member !== null);
+    return tsClazz.members.map((member) => {
+      const result = reflectClassMember(member);
+      if (result === null) {
+        return null;
+      }
+      return {
+        ...result,
+        decorators: this.getDecoratorsOfDeclaration(member)
+      };
+    }).filter((member) => member !== null);
   }
   getConstructorParameters(clazz) {
     const tsClazz = castDeclarationToClassOrDie(clazz);
@@ -656,51 +689,6 @@ var TypeScriptReflectionHost = class {
       args
     };
   }
-  _reflectMember(node) {
-    let kind = null;
-    let value = null;
-    let name = null;
-    let nameNode = null;
-    if (ts5.isPropertyDeclaration(node)) {
-      kind = ClassMemberKind.Property;
-      value = node.initializer || null;
-    } else if (ts5.isGetAccessorDeclaration(node)) {
-      kind = ClassMemberKind.Getter;
-    } else if (ts5.isSetAccessorDeclaration(node)) {
-      kind = ClassMemberKind.Setter;
-    } else if (ts5.isMethodDeclaration(node)) {
-      kind = ClassMemberKind.Method;
-    } else if (ts5.isConstructorDeclaration(node)) {
-      kind = ClassMemberKind.Constructor;
-    } else {
-      return null;
-    }
-    if (ts5.isConstructorDeclaration(node)) {
-      name = "constructor";
-    } else if (ts5.isIdentifier(node.name)) {
-      name = node.name.text;
-      nameNode = node.name;
-    } else if (ts5.isStringLiteral(node.name)) {
-      name = node.name.text;
-      nameNode = node.name;
-    } else {
-      return null;
-    }
-    const decorators = this.getDecoratorsOfDeclaration(node);
-    const modifiers = ts5.getModifiers(node);
-    const isStatic = modifiers !== void 0 && modifiers.some((mod) => mod.kind === ts5.SyntaxKind.StaticKeyword);
-    return {
-      node,
-      implementation: node,
-      kind,
-      type: node.type || null,
-      name,
-      nameNode,
-      decorators,
-      value,
-      isStatic
-    };
-  }
   getLocalExportedDeclarationsOfSourceFile(file) {
     const cacheSf = file;
     if (cacheSf[LocalExportedDeclarations] !== void 0) {
@@ -792,6 +780,83 @@ function filterToMembersWithDecorator(members, name, module) {
     return { member, decorators };
   }).filter((value) => value !== null);
 }
+function extractModifiersOfMember(node) {
+  const modifiers = ts5.getModifiers(node);
+  let isStatic = false;
+  let isReadonly = false;
+  let accessLevel = ClassMemberAccessLevel.PublicWritable;
+  if (modifiers !== void 0) {
+    for (const modifier of modifiers) {
+      switch (modifier.kind) {
+        case ts5.SyntaxKind.StaticKeyword:
+          isStatic = true;
+          break;
+        case ts5.SyntaxKind.PrivateKeyword:
+          accessLevel = ClassMemberAccessLevel.Private;
+          break;
+        case ts5.SyntaxKind.ProtectedKeyword:
+          accessLevel = ClassMemberAccessLevel.Protected;
+          break;
+        case ts5.SyntaxKind.ReadonlyKeyword:
+          isReadonly = true;
+          break;
+      }
+    }
+  }
+  if (isReadonly && accessLevel === ClassMemberAccessLevel.PublicWritable) {
+    accessLevel = ClassMemberAccessLevel.PublicReadonly;
+  }
+  if (node.name !== void 0 && ts5.isPrivateIdentifier(node.name)) {
+    accessLevel = ClassMemberAccessLevel.EcmaScriptPrivate;
+  }
+  return { accessLevel, isStatic };
+}
+function reflectClassMember(node) {
+  let kind = null;
+  let value = null;
+  let name = null;
+  let nameNode = null;
+  if (ts5.isPropertyDeclaration(node)) {
+    kind = ClassMemberKind.Property;
+    value = node.initializer || null;
+  } else if (ts5.isGetAccessorDeclaration(node)) {
+    kind = ClassMemberKind.Getter;
+  } else if (ts5.isSetAccessorDeclaration(node)) {
+    kind = ClassMemberKind.Setter;
+  } else if (ts5.isMethodDeclaration(node)) {
+    kind = ClassMemberKind.Method;
+  } else if (ts5.isConstructorDeclaration(node)) {
+    kind = ClassMemberKind.Constructor;
+  } else {
+    return null;
+  }
+  if (ts5.isConstructorDeclaration(node)) {
+    name = "constructor";
+  } else if (ts5.isIdentifier(node.name)) {
+    name = node.name.text;
+    nameNode = node.name;
+  } else if (ts5.isStringLiteral(node.name)) {
+    name = node.name.text;
+    nameNode = node.name;
+  } else if (ts5.isPrivateIdentifier(node.name)) {
+    name = node.name.text;
+    nameNode = node.name;
+  } else {
+    return null;
+  }
+  const { accessLevel, isStatic } = extractModifiersOfMember(node);
+  return {
+    node,
+    implementation: node,
+    kind,
+    type: node.type || null,
+    accessLevel,
+    name,
+    nameNode,
+    value,
+    isStatic
+  };
+}
 function reflectObjectLiteral(node) {
   const map = /* @__PURE__ */ new Map();
   node.properties.forEach((prop) => {
@@ -856,7 +921,7 @@ function getExportedName(decl, originalId) {
 }
 var LocalExportedDeclarations = Symbol("LocalExportedDeclarations");
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/typescript.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/typescript.mjs
 import ts6 from "typescript";
 var TS = /\.tsx?$/i;
 var D_TS = /\.d\.ts$/i;
@@ -957,7 +1022,7 @@ function toUnredirectedSourceFile(sf) {
   return redirectInfo.unredirected;
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/references.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/references.mjs
 var Reference = class {
   constructor(node, bestGuessOwningModule = null) {
     this.node = node;
@@ -1026,14 +1091,14 @@ var Reference = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
 import { ExternalExpr as ExternalExpr2 } from "@angular/compiler";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
 import { ExternalExpr, ExternalReference, WrappedNodeExpr } from "@angular/compiler";
 import ts7 from "typescript";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/find_export.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/find_export.mjs
 function findExportedNameOfNode(target, file, reflector) {
   const exports = reflector.getExportsOfModule(file);
   if (exports === null) {
@@ -1053,7 +1118,7 @@ function findExportedNameOfNode(target, file, reflector) {
   return foundExportName;
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
 var ImportFlags;
 (function(ImportFlags2) {
   ImportFlags2[ImportFlags2["None"] = 0] = "None";
@@ -1282,7 +1347,7 @@ var UnifiedModulesStrategy = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
 var CHARS_TO_ESCAPE = /[^a-zA-Z0-9/_]/g;
 var UnifiedModulesAliasingHost = class {
   constructor(unifiedModulesHost) {
@@ -1349,7 +1414,7 @@ var AliasStrategy = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/path.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/path.mjs
 function relativePathBetween(from, to) {
   const relativePath = stripExtension(relative(dirname(resolve(from)), resolve(to)));
   return relativePath !== "" ? toRelativeImport(relativePath) : null;
@@ -1358,11 +1423,8 @@ function normalizeSeparators(path) {
   return path.replace(/\\/g, "/");
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/core.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/core.mjs
 var NoopImportRewriter = class {
-  shouldImportSymbol(symbol, specifier) {
-    return true;
-  }
   rewriteSymbol(symbol, specifier) {
     return symbol;
   }
@@ -1390,9 +1452,6 @@ var R3SymbolsImportRewriter = class {
   constructor(r3SymbolsPath) {
     this.r3SymbolsPath = r3SymbolsPath;
   }
-  shouldImportSymbol(symbol, specifier) {
-    return true;
-  }
   rewriteSymbol(symbol, specifier) {
     if (specifier !== CORE_MODULE) {
       return symbol;
@@ -1417,7 +1476,7 @@ function validateAndRewriteCoreSymbol(name) {
   return CORE_SUPPORTED_SYMBOLS.get(name);
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/patch_alias_reference_resolution.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/patch_alias_reference_resolution.mjs
 import ts8 from "typescript";
 var patchedReferencedAliasesSymbol = Symbol("patchedReferencedAliases");
 function loadIsReferencedAliasDeclarationPatch(context) {
@@ -1452,7 +1511,7 @@ function throwIncompatibleTransformationContextError() {
   throw Error("Angular compiler is incompatible with this version of the TypeScript compiler.\n\nIf you recently updated TypeScript and this issue surfaces now, consider downgrading.\n\nPlease report an issue on the Angular repositories when this issue surfaces and you are using a supposedly compatible TypeScript version.");
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/default.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/default.mjs
 var DefaultImportDeclaration = Symbol("DefaultImportDeclaration");
 function attachDefaultImportDeclaration(expr, importDecl) {
   expr[DefaultImportDeclaration] = importDecl;
@@ -1493,7 +1552,7 @@ var DefaultImportTracker = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/deferred_symbol_tracker.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/deferred_symbol_tracker.mjs
 import ts9 from "typescript";
 var AssumeEager = "AssumeEager";
 var DeferredSymbolTracker = class {
@@ -1614,7 +1673,7 @@ var DeferredSymbolTracker = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/imported_symbols_tracker.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/imported_symbols_tracker.mjs
 import ts10 from "typescript";
 var ImportedSymbolsTracker = class {
   constructor() {
@@ -1673,7 +1732,7 @@ var ImportedSymbolsTracker = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/local_compilation_extra_imports_tracker.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/local_compilation_extra_imports_tracker.mjs
 import ts11 from "typescript";
 var LocalCompilationExtraImportsTracker = class {
   constructor(typeChecker) {
@@ -1720,7 +1779,7 @@ function removeQuotations(s) {
   return s.substring(1, s.length - 1).trim();
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/resolver.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/resolver.mjs
 var ModuleResolver = class {
   constructor(program, compilerOptions, host, moduleResolutionCache) {
     this.program = program;
@@ -1737,49 +1796,322 @@ var ModuleResolver = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager/import_manager.mjs
+import ts16 from "typescript";
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager/check_unique_identifier_name.mjs
 import ts12 from "typescript";
+function createGenerateUniqueIdentifierHelper() {
+  const generatedIdentifiers = /* @__PURE__ */ new Set();
+  return (sourceFile, symbolName) => {
+    const sf = sourceFile;
+    if (sf.identifiers === void 0) {
+      throw new Error("Source file unexpectedly lacks map of parsed `identifiers`.");
+    }
+    const isUniqueIdentifier = (name2) => !sf.identifiers.has(name2) && !generatedIdentifiers.has(name2);
+    if (isUniqueIdentifier(symbolName)) {
+      generatedIdentifiers.add(symbolName);
+      return null;
+    }
+    let name = null;
+    let counter = 1;
+    do {
+      name = `${symbolName}_${counter++}`;
+    } while (!isUniqueIdentifier(name));
+    generatedIdentifiers.add(name);
+    return ts12.factory.createUniqueName(name, ts12.GeneratedIdentifierFlags.Optimistic);
+  };
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager/import_typescript_transform.mjs
+import ts13 from "typescript";
+function createTsTransformForImportManager(manager, extraStatementsForFiles) {
+  return (ctx) => {
+    const { affectedFiles, newImports, updatedImports, reusedOriginalAliasDeclarations } = manager.finalize();
+    if (reusedOriginalAliasDeclarations.size > 0) {
+      const referencedAliasDeclarations = loadIsReferencedAliasDeclarationPatch(ctx);
+      reusedOriginalAliasDeclarations.forEach((aliasDecl) => referencedAliasDeclarations.add(aliasDecl));
+    }
+    if (extraStatementsForFiles !== void 0) {
+      for (const [fileName, statements] of extraStatementsForFiles.entries()) {
+        if (statements.length > 0) {
+          affectedFiles.add(fileName);
+        }
+      }
+    }
+    const visitStatement = (node) => {
+      if (!ts13.isImportDeclaration(node) || node.importClause === void 0 || !ts13.isImportClause(node.importClause)) {
+        return node;
+      }
+      const clause = node.importClause;
+      if (clause.namedBindings === void 0 || !ts13.isNamedImports(clause.namedBindings) || !updatedImports.has(clause.namedBindings)) {
+        return node;
+      }
+      const newClause = ctx.factory.updateImportClause(clause, clause.isTypeOnly, clause.name, updatedImports.get(clause.namedBindings));
+      const newImport = ctx.factory.updateImportDeclaration(node, node.modifiers, newClause, node.moduleSpecifier, node.attributes);
+      ts13.setOriginalNode(newImport, { importClause: newClause, kind: newImport.kind });
+      return newImport;
+    };
+    return (sourceFile) => {
+      var _a, _b;
+      if (!affectedFiles.has(sourceFile.fileName)) {
+        return sourceFile;
+      }
+      sourceFile = ts13.visitEachChild(sourceFile, visitStatement, ctx);
+      const extraStatements = (_a = extraStatementsForFiles == null ? void 0 : extraStatementsForFiles.get(sourceFile.fileName)) != null ? _a : [];
+      const existingImports = [];
+      const body = [];
+      for (const statement of sourceFile.statements) {
+        if (isImportStatement(statement)) {
+          existingImports.push(statement);
+        } else {
+          body.push(statement);
+        }
+      }
+      return ctx.factory.updateSourceFile(sourceFile, [
+        ...existingImports,
+        ...(_b = newImports.get(sourceFile.fileName)) != null ? _b : [],
+        ...extraStatements,
+        ...body
+      ], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+    };
+  };
+}
+function isImportStatement(stmt) {
+  return ts13.isImportDeclaration(stmt) || ts13.isImportEqualsDeclaration(stmt) || ts13.isNamespaceImport(stmt);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager/reuse_generated_imports.mjs
+import ts14 from "typescript";
+function attemptToReuseGeneratedImports(tracker, request) {
+  const requestHash = hashImportRequest(request);
+  const existingExactImport = tracker.directReuseCache.get(requestHash);
+  if (existingExactImport !== void 0) {
+    return existingExactImport;
+  }
+  const potentialNamespaceImport = tracker.namespaceImportReuseCache.get(request.exportModuleSpecifier);
+  if (potentialNamespaceImport === void 0) {
+    return null;
+  }
+  if (request.exportSymbolName === null) {
+    return potentialNamespaceImport;
+  }
+  return [potentialNamespaceImport, ts14.factory.createIdentifier(request.exportSymbolName)];
+}
+function captureGeneratedImport(request, tracker, referenceNode) {
+  tracker.directReuseCache.set(hashImportRequest(request), referenceNode);
+  if (request.exportSymbolName === null && !Array.isArray(referenceNode)) {
+    tracker.namespaceImportReuseCache.set(request.exportModuleSpecifier, referenceNode);
+  }
+}
+function hashImportRequest(req) {
+  return `${req.requestedFile.fileName}:${req.exportModuleSpecifier}:${req.exportSymbolName}`;
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager/reuse_source_file_imports.mjs
+import ts15 from "typescript";
+function attemptToReuseExistingSourceFileImports(tracker, sourceFile, request) {
+  let candidateImportToBeUpdated = null;
+  for (let i = sourceFile.statements.length - 1; i >= 0; i--) {
+    const statement = sourceFile.statements[i];
+    if (!ts15.isImportDeclaration(statement) || !ts15.isStringLiteral(statement.moduleSpecifier)) {
+      continue;
+    }
+    if (!statement.importClause || statement.importClause.isTypeOnly) {
+      continue;
+    }
+    const moduleSpecifier = statement.moduleSpecifier.text;
+    if (moduleSpecifier !== request.exportModuleSpecifier) {
+      continue;
+    }
+    if (statement.importClause.namedBindings) {
+      const namedBindings = statement.importClause.namedBindings;
+      if (ts15.isNamespaceImport(namedBindings)) {
+        tracker.reusedAliasDeclarations.add(namedBindings);
+        if (request.exportSymbolName === null) {
+          return namedBindings.name;
+        }
+        return [namedBindings.name, ts15.factory.createIdentifier(request.exportSymbolName)];
+      }
+      if (ts15.isNamedImports(namedBindings) && request.exportSymbolName !== null) {
+        const existingElement = namedBindings.elements.find((e) => {
+          return !e.isTypeOnly && (e.propertyName ? e.propertyName.text === request.exportSymbolName : e.name.text === request.exportSymbolName);
+        });
+        if (existingElement !== void 0) {
+          tracker.reusedAliasDeclarations.add(existingElement);
+          return existingElement.name;
+        }
+        candidateImportToBeUpdated = statement;
+      }
+    }
+  }
+  if (candidateImportToBeUpdated === null || request.exportSymbolName === null) {
+    return null;
+  }
+  if (!tracker.updatedImports.has(candidateImportToBeUpdated)) {
+    tracker.updatedImports.set(candidateImportToBeUpdated, []);
+  }
+  const symbolsToBeImported = tracker.updatedImports.get(candidateImportToBeUpdated);
+  const propertyName = ts15.factory.createIdentifier(request.exportSymbolName);
+  const fileUniqueAlias = tracker.generateUniqueIdentifier(sourceFile, request.exportSymbolName);
+  symbolsToBeImported.push({
+    propertyName,
+    fileUniqueAlias
+  });
+  return fileUniqueAlias != null ? fileUniqueAlias : propertyName;
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager/import_manager.mjs
+var presetImportManagerForceNamespaceImports = {
+  disableOriginalSourceFileReuse: true,
+  forceGenerateNamespacesForNewImports: true
+};
 var ImportManager = class {
-  constructor(rewriter = new NoopImportRewriter(), prefix = "i", factory = ts12.factory) {
-    this.rewriter = rewriter;
-    this.prefix = prefix;
-    this.factory = factory;
-    this.specifierToIdentifier = /* @__PURE__ */ new Map();
-    this.nextIndex = 0;
+  constructor(_config = {}) {
+    var _a;
+    this._config = _config;
+    this.newImports = /* @__PURE__ */ new Map();
+    this.nextUniqueIndex = 0;
+    this.config = {
+      shouldUseSingleQuotes: () => false,
+      rewriter: null,
+      disableOriginalSourceFileReuse: false,
+      forceGenerateNamespacesForNewImports: false,
+      namespaceImportPrefix: "i",
+      generateUniqueIdentifier: (_a = this._config.generateUniqueIdentifier) != null ? _a : createGenerateUniqueIdentifierHelper(),
+      ...this._config
+    };
+    this.reuseSourceFileImportsTracker = {
+      generateUniqueIdentifier: this.config.generateUniqueIdentifier,
+      reusedAliasDeclarations: /* @__PURE__ */ new Set(),
+      updatedImports: /* @__PURE__ */ new Map()
+    };
+    this.reuseGeneratedImportsTracker = {
+      directReuseCache: /* @__PURE__ */ new Map(),
+      namespaceImportReuseCache: /* @__PURE__ */ new Map()
+    };
   }
-  generateNamespaceImport(moduleName) {
-    if (!this.specifierToIdentifier.has(moduleName) || this.specifierToIdentifier.get(moduleName) === null) {
-      this.specifierToIdentifier.set(moduleName, this.factory.createIdentifier(`${this.prefix}${this.nextIndex++}`));
+  addSideEffectImport(requestedFile, moduleSpecifier) {
+    if (this.config.rewriter !== null) {
+      moduleSpecifier = this.config.rewriter.rewriteSpecifier(moduleSpecifier, requestedFile.fileName);
     }
-    return this.specifierToIdentifier.get(moduleName);
+    this._getNewImportsTrackerForFile(requestedFile).sideEffectImports.add(moduleSpecifier);
   }
-  generateNamedImport(moduleName, originalSymbol) {
-    const symbol = this.rewriter.rewriteSymbol(originalSymbol, moduleName);
-    if (!this.rewriter.shouldImportSymbol(symbol, moduleName)) {
-      return { moduleImport: null, symbol };
+  addImport(request) {
+    if (this.config.rewriter !== null) {
+      if (request.exportSymbolName !== null) {
+        request.exportSymbolName = this.config.rewriter.rewriteSymbol(request.exportSymbolName, request.exportModuleSpecifier);
+      }
+      request.exportModuleSpecifier = this.config.rewriter.rewriteSpecifier(request.exportModuleSpecifier, request.requestedFile.fileName);
+    }
+    const previousGeneratedImportRef = attemptToReuseGeneratedImports(this.reuseGeneratedImportsTracker, request);
+    if (previousGeneratedImportRef !== null) {
+      return createImportReference(!!request.asTypeReference, previousGeneratedImportRef);
     }
-    const moduleImport = this.generateNamespaceImport(moduleName);
-    return { moduleImport, symbol };
+    const resultImportRef = this._generateNewImport(request);
+    captureGeneratedImport(request, this.reuseGeneratedImportsTracker, resultImportRef);
+    return createImportReference(!!request.asTypeReference, resultImportRef);
   }
-  generateSideEffectImport(moduleName) {
-    if (!this.specifierToIdentifier.has(moduleName)) {
-      this.specifierToIdentifier.set(moduleName, null);
+  _generateNewImport(request) {
+    var _a;
+    const { requestedFile: sourceFile } = request;
+    const disableOriginalSourceFileReuse = this.config.disableOriginalSourceFileReuse;
+    const forceGenerateNamespacesForNewImports = this.config.forceGenerateNamespacesForNewImports;
+    if (!disableOriginalSourceFileReuse) {
+      const reuseResult = attemptToReuseExistingSourceFileImports(this.reuseSourceFileImportsTracker, sourceFile, request);
+      if (reuseResult !== null) {
+        return reuseResult;
+      }
     }
+    const { namedImports, namespaceImports } = this._getNewImportsTrackerForFile(sourceFile);
+    if (request.exportSymbolName === null || forceGenerateNamespacesForNewImports) {
+      const namespaceImportName = `${this.config.namespaceImportPrefix}${this.nextUniqueIndex++}`;
+      const namespaceImport2 = ts16.factory.createNamespaceImport((_a = this.config.generateUniqueIdentifier(sourceFile, namespaceImportName)) != null ? _a : ts16.factory.createIdentifier(namespaceImportName));
+      namespaceImports.set(request.exportModuleSpecifier, namespaceImport2);
+      captureGeneratedImport({ ...request, exportSymbolName: null }, this.reuseGeneratedImportsTracker, namespaceImport2.name);
+      if (request.exportSymbolName !== null) {
+        return [namespaceImport2.name, ts16.factory.createIdentifier(request.exportSymbolName)];
+      }
+      return namespaceImport2.name;
+    }
+    if (!namedImports.has(request.exportModuleSpecifier)) {
+      namedImports.set(request.exportModuleSpecifier, []);
+    }
+    const exportSymbolName = ts16.factory.createIdentifier(request.exportSymbolName);
+    const fileUniqueName = this.config.generateUniqueIdentifier(sourceFile, request.exportSymbolName);
+    const needsAlias = fileUniqueName !== null;
+    const specifierName = needsAlias ? fileUniqueName : exportSymbolName;
+    namedImports.get(request.exportModuleSpecifier).push(ts16.factory.createImportSpecifier(false, needsAlias ? exportSymbolName : void 0, specifierName));
+    return specifierName;
+  }
+  finalize() {
+    const affectedFiles = /* @__PURE__ */ new Set();
+    const updatedImportsResult = /* @__PURE__ */ new Map();
+    const newImportsResult = /* @__PURE__ */ new Map();
+    const addNewImport = (fileName, importDecl) => {
+      affectedFiles.add(fileName);
+      if (newImportsResult.has(fileName)) {
+        newImportsResult.get(fileName).push(importDecl);
+      } else {
+        newImportsResult.set(fileName, [importDecl]);
+      }
+    };
+    this.reuseSourceFileImportsTracker.updatedImports.forEach((expressions, importDecl) => {
+      const namedBindings = importDecl.importClause.namedBindings;
+      const newNamedBindings = ts16.factory.updateNamedImports(namedBindings, namedBindings.elements.concat(expressions.map(({ propertyName, fileUniqueAlias }) => ts16.factory.createImportSpecifier(false, fileUniqueAlias !== null ? propertyName : void 0, fileUniqueAlias != null ? fileUniqueAlias : propertyName))));
+      affectedFiles.add(importDecl.getSourceFile().fileName);
+      updatedImportsResult.set(namedBindings, newNamedBindings);
+    });
+    this.newImports.forEach(({ namedImports, namespaceImports, sideEffectImports }, sourceFile) => {
+      const useSingleQuotes = this.config.shouldUseSingleQuotes(sourceFile);
+      const fileName = sourceFile.fileName;
+      sideEffectImports.forEach((moduleName) => {
+        addNewImport(fileName, ts16.factory.createImportDeclaration(void 0, void 0, ts16.factory.createStringLiteral(moduleName)));
+      });
+      namespaceImports.forEach((namespaceImport2, moduleName) => {
+        const newImport = ts16.factory.createImportDeclaration(void 0, ts16.factory.createImportClause(false, void 0, namespaceImport2), ts16.factory.createStringLiteral(moduleName, useSingleQuotes));
+        ts16.setOriginalNode(namespaceImport2.name, newImport);
+        addNewImport(fileName, newImport);
+      });
+      namedImports.forEach((specifiers, moduleName) => {
+        const newImport = ts16.factory.createImportDeclaration(void 0, ts16.factory.createImportClause(false, void 0, ts16.factory.createNamedImports(specifiers)), ts16.factory.createStringLiteral(moduleName, useSingleQuotes));
+        addNewImport(fileName, newImport);
+      });
+    });
+    return {
+      affectedFiles,
+      newImports: newImportsResult,
+      updatedImports: updatedImportsResult,
+      reusedOriginalAliasDeclarations: this.reuseSourceFileImportsTracker.reusedAliasDeclarations
+    };
+  }
+  toTsTransform(extraStatementsMap) {
+    return createTsTransformForImportManager(this, extraStatementsMap);
   }
-  getAllImports(contextPath) {
-    const imports = [];
-    for (const [originalSpecifier, qualifier] of this.specifierToIdentifier) {
-      const specifier = this.rewriter.rewriteSpecifier(originalSpecifier, contextPath);
-      imports.push({
-        specifier,
-        qualifier
+  transformTsFile(ctx, file, extraStatementsAfterImports) {
+    const extraStatementsMap = extraStatementsAfterImports ? /* @__PURE__ */ new Map([[file.fileName, extraStatementsAfterImports]]) : void 0;
+    return this.toTsTransform(extraStatementsMap)(ctx)(file);
+  }
+  _getNewImportsTrackerForFile(file) {
+    if (!this.newImports.has(file)) {
+      this.newImports.set(file, {
+        namespaceImports: /* @__PURE__ */ new Map(),
+        namedImports: /* @__PURE__ */ new Map(),
+        sideEffectImports: /* @__PURE__ */ new Set()
       });
     }
-    return imports;
+    return this.newImports.get(file);
   }
 };
+function createImportReference(asTypeReference, ref) {
+  if (asTypeReference) {
+    return Array.isArray(ref) ? ts16.factory.createQualifiedName(ref[0], ref[1]) : ref;
+  } else {
+    return Array.isArray(ref) ? ts16.factory.createPropertyAccessExpression(ref[0], ref[1]) : ref;
+  }
+}
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/context.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/context.mjs
 var Context = class {
   constructor(isStatement) {
     this.isStatement = isStatement;
@@ -1792,7 +2124,7 @@ var Context = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/translator.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/translator.mjs
 import * as o from "@angular/compiler";
 var UNARY_OPERATORS = /* @__PURE__ */ new Map([
   [o.UnaryOperator.Minus, "-"],
@@ -1819,9 +2151,10 @@ var BINARY_OPERATORS = /* @__PURE__ */ new Map([
   [o.BinaryOperator.NullishCoalesce, "??"]
 ]);
 var ExpressionTranslatorVisitor = class {
-  constructor(factory, imports, options) {
+  constructor(factory, imports, contextFile, options) {
     this.factory = factory;
     this.imports = imports;
+    this.contextFile = contextFile;
     this.downlevelTaggedTemplates = options.downlevelTaggedTemplates === true;
     this.downlevelVariableDeclarations = options.downlevelVariableDeclarations === true;
     this.recordWrappedNode = options.recordWrappedNode || (() => {
@@ -1900,8 +2233,11 @@ var ExpressionTranslatorVisitor = class {
     return this.downlevelTaggedTemplates ? this.createES5TaggedTemplateFunctionCall(tag, template) : this.factory.createTaggedTemplate(tag, template);
   }
   createES5TaggedTemplateFunctionCall(tagHandler, { elements, expressions }) {
-    const { moduleImport, symbol } = this.imports.generateNamedImport("tslib", "__makeTemplateObject");
-    const __makeTemplateObjectHelper = moduleImport === null ? this.factory.createIdentifier(symbol) : this.factory.createPropertyAccess(moduleImport, symbol);
+    const __makeTemplateObjectHelper = this.imports.addImport({
+      exportModuleSpecifier: "tslib",
+      exportSymbolName: "__makeTemplateObject",
+      requestedFile: this.contextFile
+    });
     const cooked = [];
     const raw = [];
     for (const element of elements) {
@@ -1924,15 +2260,18 @@ var ExpressionTranslatorVisitor = class {
       if (ast.value.moduleName === null) {
         throw new Error("Invalid import without name nor moduleName");
       }
-      return this.imports.generateNamespaceImport(ast.value.moduleName);
+      return this.imports.addImport({
+        exportModuleSpecifier: ast.value.moduleName,
+        exportSymbolName: null,
+        requestedFile: this.contextFile
+      });
     }
     if (ast.value.moduleName !== null) {
-      const { moduleImport, symbol } = this.imports.generateNamedImport(ast.value.moduleName, ast.value.name);
-      if (moduleImport === null) {
-        return this.factory.createIdentifier(symbol);
-      } else {
-        return this.factory.createPropertyAccess(moduleImport, symbol);
-      }
+      return this.imports.addImport({
+        exportModuleSpecifier: ast.value.moduleName,
+        exportSymbolName: ast.value.name,
+        requestedFile: this.contextFile
+      });
     } else {
       return this.factory.createIdentifier(ast.value.name);
     }
@@ -2031,8 +2370,8 @@ function createRange(span) {
   };
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_emitter.mjs
-import ts13 from "typescript";
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_emitter.mjs
+import ts17 from "typescript";
 var INELIGIBLE = {};
 function canEmitType(type, canEmit) {
   return canEmitTypeWorker(type);
@@ -2040,13 +2379,13 @@ function canEmitType(type, canEmit) {
     return visitNode(type2) !== INELIGIBLE;
   }
   function visitNode(node) {
-    if (ts13.isImportTypeNode(node)) {
+    if (ts17.isImportTypeNode(node)) {
       return INELIGIBLE;
     }
-    if (ts13.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
+    if (ts17.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
       return INELIGIBLE;
     } else {
-      return ts13.forEachChild(node, visitNode);
+      return ts17.forEachChild(node, visitNode);
     }
   }
   function canEmitTypeReference(type2) {
@@ -2063,35 +2402,35 @@ var TypeEmitter = class {
   emitType(type) {
     const typeReferenceTransformer = (context) => {
       const visitNode = (node) => {
-        if (ts13.isImportTypeNode(node)) {
+        if (ts17.isImportTypeNode(node)) {
           throw new Error("Unable to emit import type");
         }
-        if (ts13.isTypeReferenceNode(node)) {
+        if (ts17.isTypeReferenceNode(node)) {
           return this.emitTypeReference(node);
-        } else if (ts13.isLiteralExpression(node)) {
+        } else if (ts17.isLiteralExpression(node)) {
           let clone;
-          if (ts13.isStringLiteral(node)) {
-            clone = ts13.factory.createStringLiteral(node.text);
-          } else if (ts13.isNumericLiteral(node)) {
-            clone = ts13.factory.createNumericLiteral(node.text);
-          } else if (ts13.isBigIntLiteral(node)) {
-            clone = ts13.factory.createBigIntLiteral(node.text);
-          } else if (ts13.isNoSubstitutionTemplateLiteral(node)) {
-            clone = ts13.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
-          } else if (ts13.isRegularExpressionLiteral(node)) {
-            clone = ts13.factory.createRegularExpressionLiteral(node.text);
+          if (ts17.isStringLiteral(node)) {
+            clone = ts17.factory.createStringLiteral(node.text);
+          } else if (ts17.isNumericLiteral(node)) {
+            clone = ts17.factory.createNumericLiteral(node.text);
+          } else if (ts17.isBigIntLiteral(node)) {
+            clone = ts17.factory.createBigIntLiteral(node.text);
+          } else if (ts17.isNoSubstitutionTemplateLiteral(node)) {
+            clone = ts17.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
+          } else if (ts17.isRegularExpressionLiteral(node)) {
+            clone = ts17.factory.createRegularExpressionLiteral(node.text);
           } else {
-            throw new Error(`Unsupported literal kind ${ts13.SyntaxKind[node.kind]}`);
+            throw new Error(`Unsupported literal kind ${ts17.SyntaxKind[node.kind]}`);
           }
-          ts13.setTextRange(clone, { pos: -1, end: -1 });
+          ts17.setTextRange(clone, { pos: -1, end: -1 });
           return clone;
         } else {
-          return ts13.visitEachChild(node, visitNode, context);
+          return ts17.visitEachChild(node, visitNode, context);
         }
       };
-      return (node) => ts13.visitNode(node, visitNode, ts13.isTypeNode);
+      return (node) => ts17.visitNode(node, visitNode, ts17.isTypeNode);
     };
-    return ts13.transform(type, [typeReferenceTransformer]).transformed[0];
+    return ts17.transform(type, [typeReferenceTransformer]).transformed[0];
   }
   emitTypeReference(type) {
     const translatedType = this.translator(type);
@@ -2100,27 +2439,27 @@ var TypeEmitter = class {
     }
     let typeArguments = void 0;
     if (type.typeArguments !== void 0) {
-      typeArguments = ts13.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
+      typeArguments = ts17.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
     }
-    return ts13.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
+    return ts17.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
 import * as o2 from "@angular/compiler";
-import ts15 from "typescript";
+import ts19 from "typescript";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/ts_util.mjs
-import ts14 from "typescript";
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/ts_util.mjs
+import ts18 from "typescript";
 function tsNumericExpression(value) {
   if (value < 0) {
-    const operand = ts14.factory.createNumericLiteral(Math.abs(value));
-    return ts14.factory.createPrefixUnaryExpression(ts14.SyntaxKind.MinusToken, operand);
+    const operand = ts18.factory.createNumericLiteral(Math.abs(value));
+    return ts18.factory.createPrefixUnaryExpression(ts18.SyntaxKind.MinusToken, operand);
   }
-  return ts14.factory.createNumericLiteral(value);
+  return ts18.factory.createNumericLiteral(value);
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
 function translateType(type, contextFile, reflector, refEmitter, imports) {
   return type.visitType(new TypeTranslatorVisitor(imports, contextFile, reflector, refEmitter), new Context(false));
 }
@@ -2134,16 +2473,16 @@ var TypeTranslatorVisitor = class {
   visitBuiltinType(type, context) {
     switch (type.name) {
       case o2.BuiltinTypeName.Bool:
-        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.BooleanKeyword);
+        return ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.BooleanKeyword);
       case o2.BuiltinTypeName.Dynamic:
-        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.AnyKeyword);
+        return ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.AnyKeyword);
       case o2.BuiltinTypeName.Int:
       case o2.BuiltinTypeName.Number:
-        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.NumberKeyword);
+        return ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.NumberKeyword);
       case o2.BuiltinTypeName.String:
-        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.StringKeyword);
+        return ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.StringKeyword);
       case o2.BuiltinTypeName.None:
-        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.NeverKeyword);
+        return ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.NeverKeyword);
       default:
         throw new Error(`Unsupported builtin type: ${o2.BuiltinTypeName[type.name]}`);
     }
@@ -2153,26 +2492,26 @@ var TypeTranslatorVisitor = class {
     if (type.typeParams === null) {
       return typeNode;
     }
-    if (!ts15.isTypeReferenceNode(typeNode)) {
+    if (!ts19.isTypeReferenceNode(typeNode)) {
       throw new Error("An ExpressionType with type arguments must translate into a TypeReferenceNode");
     } else if (typeNode.typeArguments !== void 0) {
       throw new Error(`An ExpressionType with type arguments cannot have multiple levels of type arguments`);
     }
     const typeArgs = type.typeParams.map((param) => this.translateType(param, context));
-    return ts15.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
+    return ts19.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
   }
   visitArrayType(type, context) {
-    return ts15.factory.createArrayTypeNode(this.translateType(type.of, context));
+    return ts19.factory.createArrayTypeNode(this.translateType(type.of, context));
   }
   visitMapType(type, context) {
-    const parameter = ts15.factory.createParameterDeclaration(void 0, void 0, "key", void 0, ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.StringKeyword));
-    const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.UnknownKeyword);
-    const indexSignature = ts15.factory.createIndexSignature(void 0, [parameter], typeArgs);
-    return ts15.factory.createTypeLiteralNode([indexSignature]);
+    const parameter = ts19.factory.createParameterDeclaration(void 0, void 0, "key", void 0, ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.StringKeyword));
+    const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.UnknownKeyword);
+    const indexSignature = ts19.factory.createIndexSignature(void 0, [parameter], typeArgs);
+    return ts19.factory.createTypeLiteralNode([indexSignature]);
   }
   visitTransplantedType(ast, context) {
     const node = ast.type instanceof Reference ? ast.type.node : ast.type;
-    if (!ts15.isTypeNode(node)) {
+    if (!ts19.isTypeNode(node)) {
       throw new Error(`A TransplantedType must wrap a TypeNode`);
     }
     const viaModule = ast.type instanceof Reference ? ast.type.bestGuessOwningModule : null;
@@ -2183,7 +2522,7 @@ var TypeTranslatorVisitor = class {
     if (ast.name === null) {
       throw new Error(`ReadVarExpr with no variable name in type`);
     }
-    return ts15.factory.createTypeQueryNode(ts15.factory.createIdentifier(ast.name));
+    return ts19.factory.createTypeQueryNode(ts19.factory.createIdentifier(ast.name));
   }
   visitWriteVarExpr(expr, context) {
     throw new Error("Method not implemented.");
@@ -2205,15 +2544,15 @@ var TypeTranslatorVisitor = class {
   }
   visitLiteralExpr(ast, context) {
     if (ast.value === null) {
-      return ts15.factory.createLiteralTypeNode(ts15.factory.createNull());
+      return ts19.factory.createLiteralTypeNode(ts19.factory.createNull());
     } else if (ast.value === void 0) {
-      return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.UndefinedKeyword);
+      return ts19.factory.createKeywordTypeNode(ts19.SyntaxKind.UndefinedKeyword);
     } else if (typeof ast.value === "boolean") {
-      return ts15.factory.createLiteralTypeNode(ast.value ? ts15.factory.createTrue() : ts15.factory.createFalse());
+      return ts19.factory.createLiteralTypeNode(ast.value ? ts19.factory.createTrue() : ts19.factory.createFalse());
     } else if (typeof ast.value === "number") {
-      return ts15.factory.createLiteralTypeNode(tsNumericExpression(ast.value));
+      return ts19.factory.createLiteralTypeNode(tsNumericExpression(ast.value));
     } else {
-      return ts15.factory.createLiteralTypeNode(ts15.factory.createStringLiteral(ast.value));
+      return ts19.factory.createLiteralTypeNode(ts19.factory.createStringLiteral(ast.value));
     }
   }
   visitLocalizedString(ast, context) {
@@ -2223,11 +2562,14 @@ var TypeTranslatorVisitor = class {
     if (ast.value.moduleName === null || ast.value.name === null) {
       throw new Error(`Import unknown module or symbol`);
     }
-    const { moduleImport, symbol } = this.imports.generateNamedImport(ast.value.moduleName, ast.value.name);
-    const symbolIdentifier = ts15.factory.createIdentifier(symbol);
-    const typeName = moduleImport ? ts15.factory.createQualifiedName(moduleImport, symbolIdentifier) : symbolIdentifier;
+    const typeName = this.imports.addImport({
+      exportModuleSpecifier: ast.value.moduleName,
+      exportSymbolName: ast.value.name,
+      requestedFile: this.contextFile,
+      asTypeReference: true
+    });
     const typeArguments = ast.typeParams !== null ? ast.typeParams.map((type) => this.translateType(type, context)) : void 0;
-    return ts15.factory.createTypeReferenceNode(typeName, typeArguments);
+    return ts19.factory.createTypeReferenceNode(typeName, typeArguments);
   }
   visitConditionalExpr(ast, context) {
     throw new Error("Method not implemented.");
@@ -2258,60 +2600,60 @@ var TypeTranslatorVisitor = class {
   }
   visitLiteralArrayExpr(ast, context) {
     const values = ast.entries.map((expr) => this.translateExpression(expr, context));
-    return ts15.factory.createTupleTypeNode(values);
+    return ts19.factory.createTupleTypeNode(values);
   }
   visitLiteralMapExpr(ast, context) {
     const entries = ast.entries.map((entry) => {
       const { key, quoted } = entry;
       const type = this.translateExpression(entry.value, context);
-      return ts15.factory.createPropertySignature(
+      return ts19.factory.createPropertySignature(
         void 0,
-        quoted ? ts15.factory.createStringLiteral(key) : key,
+        quoted ? ts19.factory.createStringLiteral(key) : key,
         void 0,
         type
       );
     });
-    return ts15.factory.createTypeLiteralNode(entries);
+    return ts19.factory.createTypeLiteralNode(entries);
   }
   visitCommaExpr(ast, context) {
     throw new Error("Method not implemented.");
   }
   visitWrappedNodeExpr(ast, context) {
     const node = ast.node;
-    if (ts15.isEntityName(node)) {
-      return ts15.factory.createTypeReferenceNode(node, void 0);
-    } else if (ts15.isTypeNode(node)) {
+    if (ts19.isEntityName(node)) {
+      return ts19.factory.createTypeReferenceNode(node, void 0);
+    } else if (ts19.isTypeNode(node)) {
       return node;
-    } else if (ts15.isLiteralExpression(node)) {
-      return ts15.factory.createLiteralTypeNode(node);
+    } else if (ts19.isLiteralExpression(node)) {
+      return ts19.factory.createLiteralTypeNode(node);
     } else {
-      throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${ts15.SyntaxKind[node.kind]}`);
+      throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${ts19.SyntaxKind[node.kind]}`);
     }
   }
   visitTypeofExpr(ast, context) {
     const typeNode = this.translateExpression(ast.expr, context);
-    if (!ts15.isTypeReferenceNode(typeNode)) {
+    if (!ts19.isTypeReferenceNode(typeNode)) {
       throw new Error(`The target of a typeof expression must be a type reference, but it was
-          ${ts15.SyntaxKind[typeNode.kind]}`);
+          ${ts19.SyntaxKind[typeNode.kind]}`);
     }
-    return ts15.factory.createTypeQueryNode(typeNode.typeName);
+    return ts19.factory.createTypeQueryNode(typeNode.typeName);
   }
   translateType(type, context) {
     const typeNode = type.visitType(this, context);
-    if (!ts15.isTypeNode(typeNode)) {
-      throw new Error(`A Type must translate to a TypeNode, but was ${ts15.SyntaxKind[typeNode.kind]}`);
+    if (!ts19.isTypeNode(typeNode)) {
+      throw new Error(`A Type must translate to a TypeNode, but was ${ts19.SyntaxKind[typeNode.kind]}`);
     }
     return typeNode;
   }
   translateExpression(expr, context) {
     const typeNode = expr.visitExpression(this, context);
-    if (!ts15.isTypeNode(typeNode)) {
-      throw new Error(`An Expression must translate to a TypeNode, but was ${ts15.SyntaxKind[typeNode.kind]}`);
+    if (!ts19.isTypeNode(typeNode)) {
+      throw new Error(`An Expression must translate to a TypeNode, but was ${ts19.SyntaxKind[typeNode.kind]}`);
     }
     return typeNode;
   }
   translateTypeReference(type, context, viaModule) {
-    const target = ts15.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
+    const target = ts19.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
     const declaration = this.reflector.getDeclarationOfIdentifier(target);
     if (declaration === null) {
       throw new Error(`Unable to statically determine the declaration file of type node ${target.text}`);
@@ -2327,79 +2669,79 @@ var TypeTranslatorVisitor = class {
     const emittedType = this.refEmitter.emit(reference, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowAmbientReferences);
     assertSuccessfulReferenceEmit(emittedType, target, "type");
     const typeNode = this.translateExpression(emittedType.expression, context);
-    if (!ts15.isTypeReferenceNode(typeNode)) {
-      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts15.SyntaxKind[typeNode.kind]}.`);
+    if (!ts19.isTypeReferenceNode(typeNode)) {
+      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts19.SyntaxKind[typeNode.kind]}.`);
     }
     return typeNode;
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.mjs
-import ts16 from "typescript";
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.mjs
+import ts20 from "typescript";
 var PureAnnotation;
 (function(PureAnnotation2) {
   PureAnnotation2["CLOSURE"] = "* @pureOrBreakMyCode ";
   PureAnnotation2["TERSER"] = "@__PURE__";
 })(PureAnnotation || (PureAnnotation = {}));
 var UNARY_OPERATORS2 = {
-  "+": ts16.SyntaxKind.PlusToken,
-  "-": ts16.SyntaxKind.MinusToken,
-  "!": ts16.SyntaxKind.ExclamationToken
+  "+": ts20.SyntaxKind.PlusToken,
+  "-": ts20.SyntaxKind.MinusToken,
+  "!": ts20.SyntaxKind.ExclamationToken
 };
 var BINARY_OPERATORS2 = {
-  "&&": ts16.SyntaxKind.AmpersandAmpersandToken,
-  ">": ts16.SyntaxKind.GreaterThanToken,
-  ">=": ts16.SyntaxKind.GreaterThanEqualsToken,
-  "&": ts16.SyntaxKind.AmpersandToken,
-  "|": ts16.SyntaxKind.BarToken,
-  "/": ts16.SyntaxKind.SlashToken,
-  "==": ts16.SyntaxKind.EqualsEqualsToken,
-  "===": ts16.SyntaxKind.EqualsEqualsEqualsToken,
-  "<": ts16.SyntaxKind.LessThanToken,
-  "<=": ts16.SyntaxKind.LessThanEqualsToken,
-  "-": ts16.SyntaxKind.MinusToken,
-  "%": ts16.SyntaxKind.PercentToken,
-  "*": ts16.SyntaxKind.AsteriskToken,
-  "!=": ts16.SyntaxKind.ExclamationEqualsToken,
-  "!==": ts16.SyntaxKind.ExclamationEqualsEqualsToken,
-  "||": ts16.SyntaxKind.BarBarToken,
-  "+": ts16.SyntaxKind.PlusToken,
-  "??": ts16.SyntaxKind.QuestionQuestionToken
+  "&&": ts20.SyntaxKind.AmpersandAmpersandToken,
+  ">": ts20.SyntaxKind.GreaterThanToken,
+  ">=": ts20.SyntaxKind.GreaterThanEqualsToken,
+  "&": ts20.SyntaxKind.AmpersandToken,
+  "|": ts20.SyntaxKind.BarToken,
+  "/": ts20.SyntaxKind.SlashToken,
+  "==": ts20.SyntaxKind.EqualsEqualsToken,
+  "===": ts20.SyntaxKind.EqualsEqualsEqualsToken,
+  "<": ts20.SyntaxKind.LessThanToken,
+  "<=": ts20.SyntaxKind.LessThanEqualsToken,
+  "-": ts20.SyntaxKind.MinusToken,
+  "%": ts20.SyntaxKind.PercentToken,
+  "*": ts20.SyntaxKind.AsteriskToken,
+  "!=": ts20.SyntaxKind.ExclamationEqualsToken,
+  "!==": ts20.SyntaxKind.ExclamationEqualsEqualsToken,
+  "||": ts20.SyntaxKind.BarBarToken,
+  "+": ts20.SyntaxKind.PlusToken,
+  "??": ts20.SyntaxKind.QuestionQuestionToken
 };
 var VAR_TYPES = {
-  "const": ts16.NodeFlags.Const,
-  "let": ts16.NodeFlags.Let,
-  "var": ts16.NodeFlags.None
+  "const": ts20.NodeFlags.Const,
+  "let": ts20.NodeFlags.Let,
+  "var": ts20.NodeFlags.None
 };
 var TypeScriptAstFactory = class {
   constructor(annotateForClosureCompiler) {
     this.annotateForClosureCompiler = annotateForClosureCompiler;
     this.externalSourceFiles = /* @__PURE__ */ new Map();
     this.attachComments = attachComments;
-    this.createArrayLiteral = ts16.factory.createArrayLiteralExpression;
-    this.createElementAccess = ts16.factory.createElementAccessExpression;
-    this.createExpressionStatement = ts16.factory.createExpressionStatement;
-    this.createIdentifier = ts16.factory.createIdentifier;
-    this.createParenthesizedExpression = ts16.factory.createParenthesizedExpression;
-    this.createPropertyAccess = ts16.factory.createPropertyAccessExpression;
-    this.createThrowStatement = ts16.factory.createThrowStatement;
-    this.createTypeOfExpression = ts16.factory.createTypeOfExpression;
+    this.createArrayLiteral = ts20.factory.createArrayLiteralExpression;
+    this.createElementAccess = ts20.factory.createElementAccessExpression;
+    this.createExpressionStatement = ts20.factory.createExpressionStatement;
+    this.createIdentifier = ts20.factory.createIdentifier;
+    this.createParenthesizedExpression = ts20.factory.createParenthesizedExpression;
+    this.createPropertyAccess = ts20.factory.createPropertyAccessExpression;
+    this.createThrowStatement = ts20.factory.createThrowStatement;
+    this.createTypeOfExpression = ts20.factory.createTypeOfExpression;
   }
   createAssignment(target, value) {
-    return ts16.factory.createBinaryExpression(target, ts16.SyntaxKind.EqualsToken, value);
+    return ts20.factory.createBinaryExpression(target, ts20.SyntaxKind.EqualsToken, value);
   }
   createBinaryExpression(leftOperand, operator, rightOperand) {
-    return ts16.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS2[operator], rightOperand);
+    return ts20.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS2[operator], rightOperand);
   }
   createBlock(body) {
-    return ts16.factory.createBlock(body);
+    return ts20.factory.createBlock(body);
   }
   createCallExpression(callee, args, pure) {
-    const call = ts16.factory.createCallExpression(callee, void 0, args);
+    const call = ts20.factory.createCallExpression(callee, void 0, args);
     if (pure) {
-      ts16.addSyntheticLeadingComment(
+      ts20.addSyntheticLeadingComment(
         call,
-        ts16.SyntaxKind.MultiLineCommentTrivia,
+        ts20.SyntaxKind.MultiLineCommentTrivia,
         this.annotateForClosureCompiler ? PureAnnotation.CLOSURE : PureAnnotation.TERSER,
         false
       );
@@ -2407,64 +2749,64 @@ var TypeScriptAstFactory = class {
     return call;
   }
   createConditional(condition, whenTrue, whenFalse) {
-    return ts16.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
+    return ts20.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
   }
   createDynamicImport(url) {
-    return ts16.factory.createCallExpression(
-      ts16.factory.createToken(ts16.SyntaxKind.ImportKeyword),
+    return ts20.factory.createCallExpression(
+      ts20.factory.createToken(ts20.SyntaxKind.ImportKeyword),
       void 0,
-      [ts16.factory.createStringLiteral(url)]
+      [ts20.factory.createStringLiteral(url)]
     );
   }
   createFunctionDeclaration(functionName, parameters, body) {
-    if (!ts16.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts16.SyntaxKind[body.kind]}.`);
+    if (!ts20.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts20.SyntaxKind[body.kind]}.`);
     }
-    return ts16.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => ts16.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return ts20.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => ts20.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
   }
   createFunctionExpression(functionName, parameters, body) {
-    if (!ts16.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts16.SyntaxKind[body.kind]}.`);
+    if (!ts20.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts20.SyntaxKind[body.kind]}.`);
     }
-    return ts16.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => ts16.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return ts20.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => ts20.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
   }
   createArrowFunctionExpression(parameters, body) {
-    if (ts16.isStatement(body) && !ts16.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts16.SyntaxKind[body.kind]}.`);
+    if (ts20.isStatement(body) && !ts20.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts20.SyntaxKind[body.kind]}.`);
     }
-    return ts16.factory.createArrowFunction(void 0, void 0, parameters.map((param) => ts16.factory.createParameterDeclaration(void 0, void 0, param)), void 0, void 0, body);
+    return ts20.factory.createArrowFunction(void 0, void 0, parameters.map((param) => ts20.factory.createParameterDeclaration(void 0, void 0, param)), void 0, void 0, body);
   }
   createIfStatement(condition, thenStatement, elseStatement) {
-    return ts16.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
+    return ts20.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
   }
   createLiteral(value) {
     if (value === void 0) {
-      return ts16.factory.createIdentifier("undefined");
+      return ts20.factory.createIdentifier("undefined");
     } else if (value === null) {
-      return ts16.factory.createNull();
+      return ts20.factory.createNull();
     } else if (typeof value === "boolean") {
-      return value ? ts16.factory.createTrue() : ts16.factory.createFalse();
+      return value ? ts20.factory.createTrue() : ts20.factory.createFalse();
     } else if (typeof value === "number") {
       return tsNumericExpression(value);
     } else {
-      return ts16.factory.createStringLiteral(value);
+      return ts20.factory.createStringLiteral(value);
     }
   }
   createNewExpression(expression, args) {
-    return ts16.factory.createNewExpression(expression, void 0, args);
+    return ts20.factory.createNewExpression(expression, void 0, args);
   }
   createObjectLiteral(properties) {
-    return ts16.factory.createObjectLiteralExpression(properties.map((prop) => ts16.factory.createPropertyAssignment(prop.quoted ? ts16.factory.createStringLiteral(prop.propertyName) : ts16.factory.createIdentifier(prop.propertyName), prop.value)));
+    return ts20.factory.createObjectLiteralExpression(properties.map((prop) => ts20.factory.createPropertyAssignment(prop.quoted ? ts20.factory.createStringLiteral(prop.propertyName) : ts20.factory.createIdentifier(prop.propertyName), prop.value)));
   }
   createReturnStatement(expression) {
-    return ts16.factory.createReturnStatement(expression != null ? expression : void 0);
+    return ts20.factory.createReturnStatement(expression != null ? expression : void 0);
   }
   createTaggedTemplate(tag, template) {
     let templateLiteral;
     const length = template.elements.length;
     const head = template.elements[0];
     if (length === 1) {
-      templateLiteral = ts16.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+      templateLiteral = ts20.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
     } else {
       const spans = [];
       for (let i = 1; i < length - 1; i++) {
@@ -2473,7 +2815,7 @@ var TypeScriptAstFactory = class {
         if (range !== null) {
           this.setSourceMapRange(middle, range);
         }
-        spans.push(ts16.factory.createTemplateSpan(template.expressions[i - 1], middle));
+        spans.push(ts20.factory.createTemplateSpan(template.expressions[i - 1], middle));
       }
       const resolvedExpression = template.expressions[length - 2];
       const templatePart = template.elements[length - 1];
@@ -2481,19 +2823,19 @@ var TypeScriptAstFactory = class {
       if (templatePart.range !== null) {
         this.setSourceMapRange(templateTail, templatePart.range);
       }
-      spans.push(ts16.factory.createTemplateSpan(resolvedExpression, templateTail));
-      templateLiteral = ts16.factory.createTemplateExpression(ts16.factory.createTemplateHead(head.cooked, head.raw), spans);
+      spans.push(ts20.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = ts20.factory.createTemplateExpression(ts20.factory.createTemplateHead(head.cooked, head.raw), spans);
     }
     if (head.range !== null) {
       this.setSourceMapRange(templateLiteral, head.range);
     }
-    return ts16.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
+    return ts20.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
   }
   createUnaryExpression(operator, operand) {
-    return ts16.factory.createPrefixUnaryExpression(UNARY_OPERATORS2[operator], operand);
+    return ts20.factory.createPrefixUnaryExpression(UNARY_OPERATORS2[operator], operand);
   }
   createVariableDeclaration(variableName, initializer, type) {
-    return ts16.factory.createVariableStatement(void 0, ts16.factory.createVariableDeclarationList([ts16.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
+    return ts20.factory.createVariableStatement(void 0, ts20.factory.createVariableDeclarationList([ts20.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
   }
   setSourceMapRange(node, sourceMapRange) {
     if (sourceMapRange === null) {
@@ -2501,42 +2843,42 @@ var TypeScriptAstFactory = class {
     }
     const url = sourceMapRange.url;
     if (!this.externalSourceFiles.has(url)) {
-      this.externalSourceFiles.set(url, ts16.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+      this.externalSourceFiles.set(url, ts20.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
     }
     const source = this.externalSourceFiles.get(url);
-    ts16.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
+    ts20.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
     return node;
   }
 };
 function createTemplateMiddle(cooked, raw) {
-  const node = ts16.factory.createTemplateHead(cooked, raw);
-  node.kind = ts16.SyntaxKind.TemplateMiddle;
+  const node = ts20.factory.createTemplateHead(cooked, raw);
+  node.kind = ts20.SyntaxKind.TemplateMiddle;
   return node;
 }
 function createTemplateTail(cooked, raw) {
-  const node = ts16.factory.createTemplateHead(cooked, raw);
-  node.kind = ts16.SyntaxKind.TemplateTail;
+  const node = ts20.factory.createTemplateHead(cooked, raw);
+  node.kind = ts20.SyntaxKind.TemplateTail;
   return node;
 }
 function attachComments(statement, leadingComments) {
   for (const comment of leadingComments) {
-    const commentKind = comment.multiline ? ts16.SyntaxKind.MultiLineCommentTrivia : ts16.SyntaxKind.SingleLineCommentTrivia;
+    const commentKind = comment.multiline ? ts20.SyntaxKind.MultiLineCommentTrivia : ts20.SyntaxKind.SingleLineCommentTrivia;
     if (comment.multiline) {
-      ts16.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+      ts20.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
     } else {
       for (const line of comment.toString().split("\n")) {
-        ts16.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+        ts20.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
       }
     }
   }
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_translator.mjs
-function translateExpression(expression, imports, options = {}) {
-  return expression.visitExpression(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new Context(false));
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_translator.mjs
+function translateExpression(contextFile, expression, imports, options = {}) {
+  return expression.visitExpression(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, contextFile, options), new Context(false));
 }
-function translateStatement(statement, imports, options = {}) {
-  return statement.visitStatement(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new Context(true));
+function translateStatement(contextFile, statement, imports, options = {}) {
+  return statement.visitStatement(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, contextFile, options), new Context(true));
 }
 
 export {
@@ -2588,13 +2930,16 @@ export {
   getDefaultImportDeclaration,
   DefaultImportTracker,
   ClassMemberKind,
+  ClassMemberAccessLevel,
   AmbientImport,
   typeNodeToValueExpr,
   entityNameToValue,
   isNamedClassDeclaration,
+  classMemberAccessLevelToString,
   TypeScriptReflectionHost,
   reflectTypeEntityToDeclaration,
   filterToMembersWithDecorator,
+  reflectClassMember,
   reflectObjectLiteral,
   DeferredSymbolTracker,
   ImportedSymbolsTracker,
@@ -2602,6 +2947,7 @@ export {
   Reference,
   ModuleResolver,
   Context,
+  presetImportManagerForceNamespaceImports,
   ImportManager,
   ExpressionTranslatorVisitor,
   canEmitType,
@@ -2624,4 +2970,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-6X7GQ6BQ.js.map
+//# sourceMappingURL=chunk-XZRJJDCL.js.map