@angular/compiler-cli 17.1.0-next.5 → 17.1.0

package/bundles/{chunk-EFMKZSXJ.js → chunk-3WRR7A6G.js}

@@ -12,12 +12,12 @@ import {
   resolve,
   stripExtension,
   toRelativeImport
-} from "./chunk-QPMYDNZG.js";
+} from "./chunk-I3M5LXMW.js";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
 import ts4 from "typescript";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/host.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/host.mjs
 import ts from "typescript";
 function isDecoratorIdentifier(exp) {
   return ts.isIdentifier(exp) || ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression) && ts.isIdentifier(exp.name);
@@ -32,7 +32,7 @@ var ClassMemberKind;
 })(ClassMemberKind || (ClassMemberKind = {}));
 var AmbientImport = {};
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/type_to_value.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/type_to_value.mjs
 import ts2 from "typescript";
 function typeToValue(typeNode, checker, isLocalCompilation) {
   var _a, _b;
@@ -205,7 +205,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/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/util.mjs
 import ts3 from "typescript";
 function isNamedClassDeclaration(node) {
   return ts3.isClassDeclaration(node) && isIdentifier(node.name);
@@ -214,7 +214,7 @@ function isIdentifier(node) {
   return node !== void 0 && ts3.isIdentifier(node);
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/typescript.mjs
 var TypeScriptReflectionHost = class {
   constructor(checker, isLocalCompilation = false) {
     this.checker = checker;
@@ -654,7 +654,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/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/typescript.mjs
 import ts5 from "typescript";
 var TS = /\.tsx?$/i;
 var D_TS = /\.d\.ts$/i;
@@ -755,7 +755,7 @@ function toUnredirectedSourceFile(sf) {
   return redirectInfo.unredirected;
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/references.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/references.mjs
 var Reference = class {
   constructor(node, bestGuessOwningModule = null) {
     this.node = node;
@@ -824,14 +824,14 @@ var Reference = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
+// bazel-out/darwin-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/darwin-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/diagnostics/src/error_code.mjs
+// bazel-out/darwin-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";
@@ -841,6 +841,9 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["DECORATOR_COLLISION"] = 1006] = "DECORATOR_COLLISION";
   ErrorCode2[ErrorCode2["VALUE_HAS_WRONG_TYPE"] = 1010] = "VALUE_HAS_WRONG_TYPE";
   ErrorCode2[ErrorCode2["VALUE_NOT_LITERAL"] = 1011] = "VALUE_NOT_LITERAL";
+  ErrorCode2[ErrorCode2["SIGNAL_INPUT_AND_DISALLOWED_DECORATOR"] = 1050] = "SIGNAL_INPUT_AND_DISALLOWED_DECORATOR";
+  ErrorCode2[ErrorCode2["SIGNAL_INPUT_AND_INPUTS_ARRAY_COLLISION"] = 1051] = "SIGNAL_INPUT_AND_INPUTS_ARRAY_COLLISION";
+  ErrorCode2[ErrorCode2["INPUT_DECLARED_ON_STATIC_MEMBER"] = 1100] = "INPUT_DECLARED_ON_STATIC_MEMBER";
   ErrorCode2[ErrorCode2["COMPONENT_MISSING_TEMPLATE"] = 2001] = "COMPONENT_MISSING_TEMPLATE";
   ErrorCode2[ErrorCode2["PIPE_MISSING_NAME"] = 2002] = "PIPE_MISSING_NAME";
   ErrorCode2[ErrorCode2["PARAM_MISSING_TOKEN"] = 2003] = "PARAM_MISSING_TOKEN";
@@ -862,6 +865,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["HOST_DIRECTIVE_MISSING_REQUIRED_BINDING"] = 2019] = "HOST_DIRECTIVE_MISSING_REQUIRED_BINDING";
   ErrorCode2[ErrorCode2["CONFLICTING_INPUT_TRANSFORM"] = 2020] = "CONFLICTING_INPUT_TRANSFORM";
   ErrorCode2[ErrorCode2["COMPONENT_INVALID_STYLE_URLS"] = 2021] = "COMPONENT_INVALID_STYLE_URLS";
+  ErrorCode2[ErrorCode2["COMPONENT_UNKNOWN_DEFERRED_IMPORT"] = 2022] = "COMPONENT_UNKNOWN_DEFERRED_IMPORT";
   ErrorCode2[ErrorCode2["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
   ErrorCode2[ErrorCode2["IMPORT_CYCLE_DETECTED"] = 3003] = "IMPORT_CYCLE_DETECTED";
   ErrorCode2[ErrorCode2["IMPORT_GENERATION_FAILURE"] = 3004] = "IMPORT_GENERATION_FAILURE";
@@ -893,6 +897,9 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["ILLEGAL_FOR_LOOP_TRACK_ACCESS"] = 8009] = "ILLEGAL_FOR_LOOP_TRACK_ACCESS";
   ErrorCode2[ErrorCode2["INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT"] = 8010] = "INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT";
   ErrorCode2[ErrorCode2["CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION"] = 8011] = "CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION";
+  ErrorCode2[ErrorCode2["DEFERRED_PIPE_USED_EAGERLY"] = 8012] = "DEFERRED_PIPE_USED_EAGERLY";
+  ErrorCode2[ErrorCode2["DEFERRED_DIRECTIVE_USED_EAGERLY"] = 8013] = "DEFERRED_DIRECTIVE_USED_EAGERLY";
+  ErrorCode2[ErrorCode2["DEFERRED_DEPENDENCY_IMPORTED_EAGERLY"] = 8014] = "DEFERRED_DEPENDENCY_IMPORTED_EAGERLY";
   ErrorCode2[ErrorCode2["INVALID_BANANA_IN_BOX"] = 8101] = "INVALID_BANANA_IN_BOX";
   ErrorCode2[ErrorCode2["NULLISH_COALESCING_NOT_NULLABLE"] = 8102] = "NULLISH_COALESCING_NOT_NULLABLE";
   ErrorCode2[ErrorCode2["MISSING_CONTROL_FLOW_DIRECTIVE"] = 8103] = "MISSING_CONTROL_FLOW_DIRECTIVE";
@@ -911,7 +918,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["LOCAL_COMPILATION_IMPORTED_STYLES_STRING"] = 11002] = "LOCAL_COMPILATION_IMPORTED_STYLES_STRING";
 })(ErrorCode || (ErrorCode = {}));
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/docs.mjs
+// bazel-out/darwin-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,
@@ -923,10 +930,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.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
 import ts6 from "typescript";
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/util.mjs
+// bazel-out/darwin-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");
@@ -935,7 +942,7 @@ function ngErrorCode(code) {
   return parseInt("-99" + code);
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error.mjs
 var FatalDiagnosticError = class {
   constructor(code, node, message, relatedInformation) {
     this.code = code;
@@ -991,10 +998,10 @@ function addDiagnosticChain(messageText, add) {
   return messageText;
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.mjs
+// bazel-out/darwin-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/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.mjs
 var ExtendedTemplateDiagnosticName;
 (function(ExtendedTemplateDiagnosticName2) {
   ExtendedTemplateDiagnosticName2["INVALID_BANANA_IN_BOX"] = "invalidBananaInBox";
@@ -1009,7 +1016,7 @@ var ExtendedTemplateDiagnosticName;
   ExtendedTemplateDiagnosticName2["CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION"] = "controlFlowPreventingContentProjection";
 })(ExtendedTemplateDiagnosticName || (ExtendedTemplateDiagnosticName = {}));
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/find_export.mjs
+// bazel-out/darwin-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) {
@@ -1029,7 +1036,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/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/emitter.mjs
 var ImportFlags;
 (function(ImportFlags2) {
   ImportFlags2[ImportFlags2["None"] = 0] = "None";
@@ -1258,7 +1265,7 @@ var UnifiedModulesStrategy = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/alias.mjs
+// bazel-out/darwin-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) {
@@ -1325,7 +1332,7 @@ var AliasStrategy = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/path.mjs
+// bazel-out/darwin-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;
@@ -1334,7 +1341,7 @@ function normalizeSeparators(path) {
   return path.replace(/\\/g, "/");
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/core.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/core.mjs
 var NoopImportRewriter = class {
   shouldImportSymbol(symbol, specifier) {
     return true;
@@ -1393,7 +1400,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/darwin-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) {
@@ -1428,7 +1435,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/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/default.mjs
 var DefaultImportDeclaration = Symbol("DefaultImportDeclaration");
 function attachDefaultImportDeclaration(expr, importDecl) {
   expr[DefaultImportDeclaration] = importDecl;
@@ -1469,13 +1476,15 @@ var DefaultImportTracker = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/deferred_symbol_tracker.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/deferred_symbol_tracker.mjs
 import ts9 from "typescript";
 var AssumeEager = "AssumeEager";
 var DeferredSymbolTracker = class {
-  constructor(typeChecker) {
+  constructor(typeChecker, onlyExplicitDeferDependencyImports) {
     this.typeChecker = typeChecker;
+    this.onlyExplicitDeferDependencyImports = onlyExplicitDeferDependencyImports;
     this.imports = /* @__PURE__ */ new Map();
+    this.explicitlyDeferredImports = /* @__PURE__ */ new Map();
   }
   extractImportedSymbols(importDecl) {
     const symbolMap = /* @__PURE__ */ new Map();
@@ -1503,12 +1512,33 @@ var DeferredSymbolTracker = class {
     }
     return symbolMap;
   }
-  markAsDeferrableCandidate(identifier, importDecl) {
-    if (!this.imports.has(importDecl)) {
-      const symbolMap2 = this.extractImportedSymbols(importDecl);
-      this.imports.set(importDecl, symbolMap2);
+  getNonRemovableDeferredImports(sourceFile, classDecl) {
+    var _a;
+    const affectedImports = [];
+    const importDecls = (_a = this.explicitlyDeferredImports.get(classDecl)) != null ? _a : [];
+    for (const importDecl of importDecls) {
+      if (importDecl.getSourceFile() === sourceFile && !this.canDefer(importDecl)) {
+        affectedImports.push(importDecl);
+      }
+    }
+    return affectedImports;
+  }
+  markAsDeferrableCandidate(identifier, importDecl, componentClassDecl, isExplicitlyDeferred) {
+    if (this.onlyExplicitDeferDependencyImports && !isExplicitlyDeferred) {
+      return;
+    }
+    if (isExplicitlyDeferred) {
+      if (this.explicitlyDeferredImports.has(componentClassDecl)) {
+        this.explicitlyDeferredImports.get(componentClassDecl).push(importDecl);
+      } else {
+        this.explicitlyDeferredImports.set(componentClassDecl, [importDecl]);
+      }
+    }
+    let symbolMap = this.imports.get(importDecl);
+    if (!symbolMap) {
+      symbolMap = this.extractImportedSymbols(importDecl);
+      this.imports.set(importDecl, symbolMap);
     }
-    const symbolMap = this.imports.get(importDecl);
     if (!symbolMap.has(identifier.text)) {
       throw new Error(`The '${identifier.text}' identifier doesn't belong to the provided import declaration.`);
     }
@@ -1567,7 +1597,7 @@ var DeferredSymbolTracker = class {
   }
 };
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/resolver.mjs
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/imports/src/resolver.mjs
 var ModuleResolver = class {
   constructor(program, compilerOptions, host, moduleResolutionCache) {
     this.program = program;
@@ -1584,6 +1614,803 @@ var ModuleResolver = class {
   }
 };
 
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/import_manager.mjs
+import ts10 from "typescript";
+var ImportManager = class {
+  constructor(rewriter = new NoopImportRewriter(), prefix = "i", factory = ts10.factory) {
+    this.rewriter = rewriter;
+    this.prefix = prefix;
+    this.factory = factory;
+    this.specifierToIdentifier = /* @__PURE__ */ new Map();
+    this.nextIndex = 0;
+  }
+  generateNamespaceImport(moduleName) {
+    if (!this.specifierToIdentifier.has(moduleName)) {
+      this.specifierToIdentifier.set(moduleName, this.factory.createIdentifier(`${this.prefix}${this.nextIndex++}`));
+    }
+    return this.specifierToIdentifier.get(moduleName);
+  }
+  generateNamedImport(moduleName, originalSymbol) {
+    const symbol = this.rewriter.rewriteSymbol(originalSymbol, moduleName);
+    if (!this.rewriter.shouldImportSymbol(symbol, moduleName)) {
+      return { moduleImport: null, symbol };
+    }
+    const moduleImport = this.generateNamespaceImport(moduleName);
+    return { moduleImport, symbol };
+  }
+  getAllImports(contextPath) {
+    const imports = [];
+    for (const [originalSpecifier, qualifier] of this.specifierToIdentifier) {
+      const specifier = this.rewriter.rewriteSpecifier(originalSpecifier, contextPath);
+      imports.push({
+        specifier,
+        qualifier
+      });
+    }
+    return imports;
+  }
+};
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/context.mjs
+var Context = class {
+  constructor(isStatement) {
+    this.isStatement = isStatement;
+  }
+  get withExpressionMode() {
+    return this.isStatement ? new Context(false) : this;
+  }
+  get withStatementMode() {
+    return !this.isStatement ? new Context(true) : this;
+  }
+};
+
+// bazel-out/darwin-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, "-"],
+  [o.UnaryOperator.Plus, "+"]
+]);
+var BINARY_OPERATORS = /* @__PURE__ */ new Map([
+  [o.BinaryOperator.And, "&&"],
+  [o.BinaryOperator.Bigger, ">"],
+  [o.BinaryOperator.BiggerEquals, ">="],
+  [o.BinaryOperator.BitwiseAnd, "&"],
+  [o.BinaryOperator.BitwiseOr, "|"],
+  [o.BinaryOperator.Divide, "/"],
+  [o.BinaryOperator.Equals, "=="],
+  [o.BinaryOperator.Identical, "==="],
+  [o.BinaryOperator.Lower, "<"],
+  [o.BinaryOperator.LowerEquals, "<="],
+  [o.BinaryOperator.Minus, "-"],
+  [o.BinaryOperator.Modulo, "%"],
+  [o.BinaryOperator.Multiply, "*"],
+  [o.BinaryOperator.NotEquals, "!="],
+  [o.BinaryOperator.NotIdentical, "!=="],
+  [o.BinaryOperator.Or, "||"],
+  [o.BinaryOperator.Plus, "+"],
+  [o.BinaryOperator.NullishCoalesce, "??"]
+]);
+var ExpressionTranslatorVisitor = class {
+  constructor(factory, imports, options) {
+    this.factory = factory;
+    this.imports = imports;
+    this.downlevelTaggedTemplates = options.downlevelTaggedTemplates === true;
+    this.downlevelVariableDeclarations = options.downlevelVariableDeclarations === true;
+    this.recordWrappedNode = options.recordWrappedNode || (() => {
+    });
+  }
+  visitDeclareVarStmt(stmt, context) {
+    var _a;
+    const varType = this.downlevelVariableDeclarations ? "var" : stmt.hasModifier(o.StmtModifier.Final) ? "const" : "let";
+    return this.attachComments(this.factory.createVariableDeclaration(stmt.name, (_a = stmt.value) == null ? void 0 : _a.visitExpression(this, context.withExpressionMode), varType), stmt.leadingComments);
+  }
+  visitDeclareFunctionStmt(stmt, context) {
+    return this.attachComments(this.factory.createFunctionDeclaration(stmt.name, stmt.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(stmt.statements, context.withStatementMode))), stmt.leadingComments);
+  }
+  visitExpressionStmt(stmt, context) {
+    return this.attachComments(this.factory.createExpressionStatement(stmt.expr.visitExpression(this, context.withStatementMode)), stmt.leadingComments);
+  }
+  visitReturnStmt(stmt, context) {
+    return this.attachComments(this.factory.createReturnStatement(stmt.value.visitExpression(this, context.withExpressionMode)), stmt.leadingComments);
+  }
+  visitIfStmt(stmt, context) {
+    return this.attachComments(this.factory.createIfStatement(stmt.condition.visitExpression(this, context), this.factory.createBlock(this.visitStatements(stmt.trueCase, context.withStatementMode)), stmt.falseCase.length > 0 ? this.factory.createBlock(this.visitStatements(stmt.falseCase, context.withStatementMode)) : null), stmt.leadingComments);
+  }
+  visitReadVarExpr(ast, _context) {
+    const identifier = this.factory.createIdentifier(ast.name);
+    this.setSourceMapRange(identifier, ast.sourceSpan);
+    return identifier;
+  }
+  visitWriteVarExpr(expr, context) {
+    const assignment = this.factory.createAssignment(this.setSourceMapRange(this.factory.createIdentifier(expr.name), expr.sourceSpan), expr.value.visitExpression(this, context));
+    return context.isStatement ? assignment : this.factory.createParenthesizedExpression(assignment);
+  }
+  visitWriteKeyExpr(expr, context) {
+    const exprContext = context.withExpressionMode;
+    const target = this.factory.createElementAccess(expr.receiver.visitExpression(this, exprContext), expr.index.visitExpression(this, exprContext));
+    const assignment = this.factory.createAssignment(target, expr.value.visitExpression(this, exprContext));
+    return context.isStatement ? assignment : this.factory.createParenthesizedExpression(assignment);
+  }
+  visitWritePropExpr(expr, context) {
+    const target = this.factory.createPropertyAccess(expr.receiver.visitExpression(this, context), expr.name);
+    return this.factory.createAssignment(target, expr.value.visitExpression(this, context));
+  }
+  visitInvokeFunctionExpr(ast, context) {
+    return this.setSourceMapRange(this.factory.createCallExpression(ast.fn.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)), ast.pure), ast.sourceSpan);
+  }
+  visitTaggedTemplateExpr(ast, context) {
+    return this.setSourceMapRange(this.createTaggedTemplateExpression(ast.tag.visitExpression(this, context), {
+      elements: ast.template.elements.map((e) => {
+        var _a;
+        return createTemplateElement({
+          cooked: e.text,
+          raw: e.rawText,
+          range: (_a = e.sourceSpan) != null ? _a : ast.sourceSpan
+        });
+      }),
+      expressions: ast.template.expressions.map((e) => e.visitExpression(this, context))
+    }), ast.sourceSpan);
+  }
+  visitInstantiateExpr(ast, context) {
+    return this.factory.createNewExpression(ast.classExpr.visitExpression(this, context), ast.args.map((arg) => arg.visitExpression(this, context)));
+  }
+  visitLiteralExpr(ast, _context) {
+    return this.setSourceMapRange(this.factory.createLiteral(ast.value), ast.sourceSpan);
+  }
+  visitLocalizedString(ast, context) {
+    const elements = [createTemplateElement(ast.serializeI18nHead())];
+    const expressions = [];
+    for (let i = 0; i < ast.expressions.length; i++) {
+      const placeholder = this.setSourceMapRange(ast.expressions[i].visitExpression(this, context), ast.getPlaceholderSourceSpan(i));
+      expressions.push(placeholder);
+      elements.push(createTemplateElement(ast.serializeI18nTemplatePart(i + 1)));
+    }
+    const localizeTag = this.factory.createIdentifier("$localize");
+    return this.setSourceMapRange(this.createTaggedTemplateExpression(localizeTag, { elements, expressions }), ast.sourceSpan);
+  }
+  createTaggedTemplateExpression(tag, template) {
+    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 cooked = [];
+    const raw = [];
+    for (const element of elements) {
+      cooked.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.cooked), element.range));
+      raw.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.raw), element.range));
+    }
+    const templateHelperCall = this.factory.createCallExpression(
+      __makeTemplateObjectHelper,
+      [this.factory.createArrayLiteral(cooked), this.factory.createArrayLiteral(raw)],
+      false
+    );
+    return this.factory.createCallExpression(
+      tagHandler,
+      [templateHelperCall, ...expressions],
+      false
+    );
+  }
+  visitExternalExpr(ast, _context) {
+    if (ast.value.name === null) {
+      if (ast.value.moduleName === null) {
+        throw new Error("Invalid import without name nor moduleName");
+      }
+      return this.imports.generateNamespaceImport(ast.value.moduleName);
+    }
+    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);
+      }
+    } else {
+      return this.factory.createIdentifier(ast.value.name);
+    }
+  }
+  visitConditionalExpr(ast, context) {
+    let cond = ast.condition.visitExpression(this, context);
+    if (ast.condition instanceof o.ConditionalExpr) {
+      cond = this.factory.createParenthesizedExpression(cond);
+    }
+    return this.factory.createConditional(cond, ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context));
+  }
+  visitDynamicImportExpr(ast, context) {
+    return this.factory.createDynamicImport(ast.url);
+  }
+  visitNotExpr(ast, context) {
+    return this.factory.createUnaryExpression("!", ast.condition.visitExpression(this, context));
+  }
+  visitFunctionExpr(ast, context) {
+    var _a;
+    return this.factory.createFunctionExpression((_a = ast.name) != null ? _a : null, ast.params.map((param) => param.name), this.factory.createBlock(this.visitStatements(ast.statements, context)));
+  }
+  visitArrowFunctionExpr(ast, context) {
+    return this.factory.createArrowFunctionExpression(ast.params.map((param) => param.name), Array.isArray(ast.body) ? this.factory.createBlock(this.visitStatements(ast.body, context)) : ast.body.visitExpression(this, context));
+  }
+  visitBinaryOperatorExpr(ast, context) {
+    if (!BINARY_OPERATORS.has(ast.operator)) {
+      throw new Error(`Unknown binary operator: ${o.BinaryOperator[ast.operator]}`);
+    }
+    return this.factory.createBinaryExpression(ast.lhs.visitExpression(this, context), BINARY_OPERATORS.get(ast.operator), ast.rhs.visitExpression(this, context));
+  }
+  visitReadPropExpr(ast, context) {
+    return this.factory.createPropertyAccess(ast.receiver.visitExpression(this, context), ast.name);
+  }
+  visitReadKeyExpr(ast, context) {
+    return this.factory.createElementAccess(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context));
+  }
+  visitLiteralArrayExpr(ast, context) {
+    return this.factory.createArrayLiteral(ast.entries.map((expr) => this.setSourceMapRange(expr.visitExpression(this, context), ast.sourceSpan)));
+  }
+  visitLiteralMapExpr(ast, context) {
+    const properties = ast.entries.map((entry) => {
+      return {
+        propertyName: entry.key,
+        quoted: entry.quoted,
+        value: entry.value.visitExpression(this, context)
+      };
+    });
+    return this.setSourceMapRange(this.factory.createObjectLiteral(properties), ast.sourceSpan);
+  }
+  visitCommaExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitWrappedNodeExpr(ast, _context) {
+    this.recordWrappedNode(ast);
+    return ast.node;
+  }
+  visitTypeofExpr(ast, context) {
+    return this.factory.createTypeOfExpression(ast.expr.visitExpression(this, context));
+  }
+  visitUnaryOperatorExpr(ast, context) {
+    if (!UNARY_OPERATORS.has(ast.operator)) {
+      throw new Error(`Unknown unary operator: ${o.UnaryOperator[ast.operator]}`);
+    }
+    return this.factory.createUnaryExpression(UNARY_OPERATORS.get(ast.operator), ast.expr.visitExpression(this, context));
+  }
+  visitStatements(statements, context) {
+    return statements.map((stmt) => stmt.visitStatement(this, context)).filter((stmt) => stmt !== void 0);
+  }
+  setSourceMapRange(ast, span) {
+    return this.factory.setSourceMapRange(ast, createRange(span));
+  }
+  attachComments(statement, leadingComments) {
+    if (leadingComments !== void 0) {
+      this.factory.attachComments(statement, leadingComments);
+    }
+    return statement;
+  }
+};
+function createTemplateElement({ cooked, raw, range }) {
+  return { cooked, raw, range: createRange(range) };
+}
+function createRange(span) {
+  if (span === null) {
+    return null;
+  }
+  const { start, end } = span;
+  const { url, content } = start.file;
+  if (!url) {
+    return null;
+  }
+  return {
+    url,
+    content,
+    start: { offset: start.offset, line: start.line, column: start.col },
+    end: { offset: end.offset, line: end.line, column: end.col }
+  };
+}
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_emitter.mjs
+import ts11 from "typescript";
+var INELIGIBLE = {};
+function canEmitType(type, canEmit) {
+  return canEmitTypeWorker(type);
+  function canEmitTypeWorker(type2) {
+    return visitNode(type2) !== INELIGIBLE;
+  }
+  function visitNode(node) {
+    if (ts11.isImportTypeNode(node)) {
+      return INELIGIBLE;
+    }
+    if (ts11.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
+      return INELIGIBLE;
+    } else {
+      return ts11.forEachChild(node, visitNode);
+    }
+  }
+  function canEmitTypeReference(type2) {
+    if (!canEmit(type2)) {
+      return false;
+    }
+    return type2.typeArguments === void 0 || type2.typeArguments.every(canEmitTypeWorker);
+  }
+}
+var TypeEmitter = class {
+  constructor(translator) {
+    this.translator = translator;
+  }
+  emitType(type) {
+    const typeReferenceTransformer = (context) => {
+      const visitNode = (node) => {
+        if (ts11.isImportTypeNode(node)) {
+          throw new Error("Unable to emit import type");
+        }
+        if (ts11.isTypeReferenceNode(node)) {
+          return this.emitTypeReference(node);
+        } else if (ts11.isLiteralExpression(node)) {
+          let clone;
+          if (ts11.isStringLiteral(node)) {
+            clone = ts11.factory.createStringLiteral(node.text);
+          } else if (ts11.isNumericLiteral(node)) {
+            clone = ts11.factory.createNumericLiteral(node.text);
+          } else if (ts11.isBigIntLiteral(node)) {
+            clone = ts11.factory.createBigIntLiteral(node.text);
+          } else if (ts11.isNoSubstitutionTemplateLiteral(node)) {
+            clone = ts11.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
+          } else if (ts11.isRegularExpressionLiteral(node)) {
+            clone = ts11.factory.createRegularExpressionLiteral(node.text);
+          } else {
+            throw new Error(`Unsupported literal kind ${ts11.SyntaxKind[node.kind]}`);
+          }
+          ts11.setTextRange(clone, { pos: -1, end: -1 });
+          return clone;
+        } else {
+          return ts11.visitEachChild(node, visitNode, context);
+        }
+      };
+      return (node) => ts11.visitNode(node, visitNode, ts11.isTypeNode);
+    };
+    return ts11.transform(type, [typeReferenceTransformer]).transformed[0];
+  }
+  emitTypeReference(type) {
+    const translatedType = this.translator(type);
+    if (translatedType === null) {
+      throw new Error("Unable to emit an unresolved reference");
+    }
+    let typeArguments = void 0;
+    if (type.typeArguments !== void 0) {
+      typeArguments = ts11.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
+    }
+    return ts11.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
+  }
+};
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
+import * as o2 from "@angular/compiler";
+import ts13 from "typescript";
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/ts_util.mjs
+import ts12 from "typescript";
+function tsNumericExpression(value) {
+  if (value < 0) {
+    const operand = ts12.factory.createNumericLiteral(Math.abs(value));
+    return ts12.factory.createPrefixUnaryExpression(ts12.SyntaxKind.MinusToken, operand);
+  }
+  return ts12.factory.createNumericLiteral(value);
+}
+
+// bazel-out/darwin-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));
+}
+var TypeTranslatorVisitor = class {
+  constructor(imports, contextFile, reflector, refEmitter) {
+    this.imports = imports;
+    this.contextFile = contextFile;
+    this.reflector = reflector;
+    this.refEmitter = refEmitter;
+  }
+  visitBuiltinType(type, context) {
+    switch (type.name) {
+      case o2.BuiltinTypeName.Bool:
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.BooleanKeyword);
+      case o2.BuiltinTypeName.Dynamic:
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.AnyKeyword);
+      case o2.BuiltinTypeName.Int:
+      case o2.BuiltinTypeName.Number:
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.NumberKeyword);
+      case o2.BuiltinTypeName.String:
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.StringKeyword);
+      case o2.BuiltinTypeName.None:
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.NeverKeyword);
+      default:
+        throw new Error(`Unsupported builtin type: ${o2.BuiltinTypeName[type.name]}`);
+    }
+  }
+  visitExpressionType(type, context) {
+    const typeNode = this.translateExpression(type.value, context);
+    if (type.typeParams === null) {
+      return typeNode;
+    }
+    if (!ts13.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 ts13.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
+  }
+  visitArrayType(type, context) {
+    return ts13.factory.createArrayTypeNode(this.translateType(type.of, context));
+  }
+  visitMapType(type, context) {
+    const parameter = ts13.factory.createParameterDeclaration(void 0, void 0, "key", void 0, ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.StringKeyword));
+    const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.UnknownKeyword);
+    const indexSignature = ts13.factory.createIndexSignature(void 0, [parameter], typeArgs);
+    return ts13.factory.createTypeLiteralNode([indexSignature]);
+  }
+  visitTransplantedType(ast, context) {
+    const node = ast.type instanceof Reference ? ast.type.node : ast.type;
+    if (!ts13.isTypeNode(node)) {
+      throw new Error(`A TransplantedType must wrap a TypeNode`);
+    }
+    const viaModule = ast.type instanceof Reference ? ast.type.bestGuessOwningModule : null;
+    const emitter = new TypeEmitter((typeRef) => this.translateTypeReference(typeRef, context, viaModule));
+    return emitter.emitType(node);
+  }
+  visitReadVarExpr(ast, context) {
+    if (ast.name === null) {
+      throw new Error(`ReadVarExpr with no variable name in type`);
+    }
+    return ts13.factory.createTypeQueryNode(ts13.factory.createIdentifier(ast.name));
+  }
+  visitWriteVarExpr(expr, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitWriteKeyExpr(expr, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitWritePropExpr(expr, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitInvokeFunctionExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitTaggedTemplateExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitInstantiateExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitLiteralExpr(ast, context) {
+    if (ast.value === null) {
+      return ts13.factory.createLiteralTypeNode(ts13.factory.createNull());
+    } else if (ast.value === void 0) {
+      return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.UndefinedKeyword);
+    } else if (typeof ast.value === "boolean") {
+      return ts13.factory.createLiteralTypeNode(ast.value ? ts13.factory.createTrue() : ts13.factory.createFalse());
+    } else if (typeof ast.value === "number") {
+      return ts13.factory.createLiteralTypeNode(tsNumericExpression(ast.value));
+    } else {
+      return ts13.factory.createLiteralTypeNode(ts13.factory.createStringLiteral(ast.value));
+    }
+  }
+  visitLocalizedString(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitExternalExpr(ast, context) {
+    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 = ts13.factory.createIdentifier(symbol);
+    const typeName = moduleImport ? ts13.factory.createQualifiedName(moduleImport, symbolIdentifier) : symbolIdentifier;
+    const typeArguments = ast.typeParams !== null ? ast.typeParams.map((type) => this.translateType(type, context)) : void 0;
+    return ts13.factory.createTypeReferenceNode(typeName, typeArguments);
+  }
+  visitConditionalExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitDynamicImportExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitNotExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitFunctionExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitArrowFunctionExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitUnaryOperatorExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitBinaryOperatorExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitReadPropExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitReadKeyExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitLiteralArrayExpr(ast, context) {
+    const values = ast.entries.map((expr) => this.translateExpression(expr, context));
+    return ts13.factory.createTupleTypeNode(values);
+  }
+  visitLiteralMapExpr(ast, context) {
+    const entries = ast.entries.map((entry) => {
+      const { key, quoted } = entry;
+      const type = this.translateExpression(entry.value, context);
+      return ts13.factory.createPropertySignature(
+        void 0,
+        quoted ? ts13.factory.createStringLiteral(key) : key,
+        void 0,
+        type
+      );
+    });
+    return ts13.factory.createTypeLiteralNode(entries);
+  }
+  visitCommaExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
+  visitWrappedNodeExpr(ast, context) {
+    const node = ast.node;
+    if (ts13.isEntityName(node)) {
+      return ts13.factory.createTypeReferenceNode(node, void 0);
+    } else if (ts13.isTypeNode(node)) {
+      return node;
+    } else if (ts13.isLiteralExpression(node)) {
+      return ts13.factory.createLiteralTypeNode(node);
+    } else {
+      throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${ts13.SyntaxKind[node.kind]}`);
+    }
+  }
+  visitTypeofExpr(ast, context) {
+    const typeNode = this.translateExpression(ast.expr, context);
+    if (!ts13.isTypeReferenceNode(typeNode)) {
+      throw new Error(`The target of a typeof expression must be a type reference, but it was
+          ${ts13.SyntaxKind[typeNode.kind]}`);
+    }
+    return ts13.factory.createTypeQueryNode(typeNode.typeName);
+  }
+  translateType(type, context) {
+    const typeNode = type.visitType(this, context);
+    if (!ts13.isTypeNode(typeNode)) {
+      throw new Error(`A Type must translate to a TypeNode, but was ${ts13.SyntaxKind[typeNode.kind]}`);
+    }
+    return typeNode;
+  }
+  translateExpression(expr, context) {
+    const typeNode = expr.visitExpression(this, context);
+    if (!ts13.isTypeNode(typeNode)) {
+      throw new Error(`An Expression must translate to a TypeNode, but was ${ts13.SyntaxKind[typeNode.kind]}`);
+    }
+    return typeNode;
+  }
+  translateTypeReference(type, context, viaModule) {
+    const target = ts13.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}`);
+    }
+    let owningModule = viaModule;
+    if (typeof declaration.viaModule === "string") {
+      owningModule = {
+        specifier: declaration.viaModule,
+        resolutionContext: type.getSourceFile().fileName
+      };
+    }
+    const reference = new Reference(declaration.node, declaration.viaModule === AmbientImport ? AmbientImport : owningModule);
+    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 (!ts13.isTypeReferenceNode(typeNode)) {
+      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts13.SyntaxKind[typeNode.kind]}.`);
+    }
+    return typeNode;
+  }
+};
+
+// bazel-out/darwin-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.mjs
+import ts14 from "typescript";
+var PureAnnotation;
+(function(PureAnnotation2) {
+  PureAnnotation2["CLOSURE"] = "* @pureOrBreakMyCode ";
+  PureAnnotation2["TERSER"] = "@__PURE__";
+})(PureAnnotation || (PureAnnotation = {}));
+var UNARY_OPERATORS2 = {
+  "+": ts14.SyntaxKind.PlusToken,
+  "-": ts14.SyntaxKind.MinusToken,
+  "!": ts14.SyntaxKind.ExclamationToken
+};
+var BINARY_OPERATORS2 = {
+  "&&": ts14.SyntaxKind.AmpersandAmpersandToken,
+  ">": ts14.SyntaxKind.GreaterThanToken,
+  ">=": ts14.SyntaxKind.GreaterThanEqualsToken,
+  "&": ts14.SyntaxKind.AmpersandToken,
+  "|": ts14.SyntaxKind.BarToken,
+  "/": ts14.SyntaxKind.SlashToken,
+  "==": ts14.SyntaxKind.EqualsEqualsToken,
+  "===": ts14.SyntaxKind.EqualsEqualsEqualsToken,
+  "<": ts14.SyntaxKind.LessThanToken,
+  "<=": ts14.SyntaxKind.LessThanEqualsToken,
+  "-": ts14.SyntaxKind.MinusToken,
+  "%": ts14.SyntaxKind.PercentToken,
+  "*": ts14.SyntaxKind.AsteriskToken,
+  "!=": ts14.SyntaxKind.ExclamationEqualsToken,
+  "!==": ts14.SyntaxKind.ExclamationEqualsEqualsToken,
+  "||": ts14.SyntaxKind.BarBarToken,
+  "+": ts14.SyntaxKind.PlusToken,
+  "??": ts14.SyntaxKind.QuestionQuestionToken
+};
+var VAR_TYPES = {
+  "const": ts14.NodeFlags.Const,
+  "let": ts14.NodeFlags.Let,
+  "var": ts14.NodeFlags.None
+};
+var TypeScriptAstFactory = class {
+  constructor(annotateForClosureCompiler) {
+    this.annotateForClosureCompiler = annotateForClosureCompiler;
+    this.externalSourceFiles = /* @__PURE__ */ new Map();
+    this.attachComments = attachComments;
+    this.createArrayLiteral = ts14.factory.createArrayLiteralExpression;
+    this.createElementAccess = ts14.factory.createElementAccessExpression;
+    this.createExpressionStatement = ts14.factory.createExpressionStatement;
+    this.createIdentifier = ts14.factory.createIdentifier;
+    this.createParenthesizedExpression = ts14.factory.createParenthesizedExpression;
+    this.createPropertyAccess = ts14.factory.createPropertyAccessExpression;
+    this.createThrowStatement = ts14.factory.createThrowStatement;
+    this.createTypeOfExpression = ts14.factory.createTypeOfExpression;
+  }
+  createAssignment(target, value) {
+    return ts14.factory.createBinaryExpression(target, ts14.SyntaxKind.EqualsToken, value);
+  }
+  createBinaryExpression(leftOperand, operator, rightOperand) {
+    return ts14.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS2[operator], rightOperand);
+  }
+  createBlock(body) {
+    return ts14.factory.createBlock(body);
+  }
+  createCallExpression(callee, args, pure) {
+    const call = ts14.factory.createCallExpression(callee, void 0, args);
+    if (pure) {
+      ts14.addSyntheticLeadingComment(
+        call,
+        ts14.SyntaxKind.MultiLineCommentTrivia,
+        this.annotateForClosureCompiler ? PureAnnotation.CLOSURE : PureAnnotation.TERSER,
+        false
+      );
+    }
+    return call;
+  }
+  createConditional(condition, whenTrue, whenFalse) {
+    return ts14.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
+  }
+  createDynamicImport(url) {
+    return ts14.factory.createCallExpression(
+      ts14.factory.createToken(ts14.SyntaxKind.ImportKeyword),
+      void 0,
+      [ts14.factory.createStringLiteral(url)]
+    );
+  }
+  createFunctionDeclaration(functionName, parameters, body) {
+    if (!ts14.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
+    }
+    return ts14.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => ts14.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+  }
+  createFunctionExpression(functionName, parameters, body) {
+    if (!ts14.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
+    }
+    return ts14.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => ts14.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+  }
+  createArrowFunctionExpression(parameters, body) {
+    if (ts14.isStatement(body) && !ts14.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
+    }
+    return ts14.factory.createArrowFunction(void 0, void 0, parameters.map((param) => ts14.factory.createParameterDeclaration(void 0, void 0, param)), void 0, void 0, body);
+  }
+  createIfStatement(condition, thenStatement, elseStatement) {
+    return ts14.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
+  }
+  createLiteral(value) {
+    if (value === void 0) {
+      return ts14.factory.createIdentifier("undefined");
+    } else if (value === null) {
+      return ts14.factory.createNull();
+    } else if (typeof value === "boolean") {
+      return value ? ts14.factory.createTrue() : ts14.factory.createFalse();
+    } else if (typeof value === "number") {
+      return tsNumericExpression(value);
+    } else {
+      return ts14.factory.createStringLiteral(value);
+    }
+  }
+  createNewExpression(expression, args) {
+    return ts14.factory.createNewExpression(expression, void 0, args);
+  }
+  createObjectLiteral(properties) {
+    return ts14.factory.createObjectLiteralExpression(properties.map((prop) => ts14.factory.createPropertyAssignment(prop.quoted ? ts14.factory.createStringLiteral(prop.propertyName) : ts14.factory.createIdentifier(prop.propertyName), prop.value)));
+  }
+  createReturnStatement(expression) {
+    return ts14.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 = ts14.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+    } else {
+      const spans = [];
+      for (let i = 1; i < length - 1; i++) {
+        const { cooked, raw, range } = template.elements[i];
+        const middle = createTemplateMiddle(cooked, raw);
+        if (range !== null) {
+          this.setSourceMapRange(middle, range);
+        }
+        spans.push(ts14.factory.createTemplateSpan(template.expressions[i - 1], middle));
+      }
+      const resolvedExpression = template.expressions[length - 2];
+      const templatePart = template.elements[length - 1];
+      const templateTail = createTemplateTail(templatePart.cooked, templatePart.raw);
+      if (templatePart.range !== null) {
+        this.setSourceMapRange(templateTail, templatePart.range);
+      }
+      spans.push(ts14.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = ts14.factory.createTemplateExpression(ts14.factory.createTemplateHead(head.cooked, head.raw), spans);
+    }
+    if (head.range !== null) {
+      this.setSourceMapRange(templateLiteral, head.range);
+    }
+    return ts14.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
+  }
+  createUnaryExpression(operator, operand) {
+    return ts14.factory.createPrefixUnaryExpression(UNARY_OPERATORS2[operator], operand);
+  }
+  createVariableDeclaration(variableName, initializer, type) {
+    return ts14.factory.createVariableStatement(void 0, ts14.factory.createVariableDeclarationList([ts14.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
+  }
+  setSourceMapRange(node, sourceMapRange) {
+    if (sourceMapRange === null) {
+      return node;
+    }
+    const url = sourceMapRange.url;
+    if (!this.externalSourceFiles.has(url)) {
+      this.externalSourceFiles.set(url, ts14.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+    }
+    const source = this.externalSourceFiles.get(url);
+    ts14.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
+    return node;
+  }
+};
+function createTemplateMiddle(cooked, raw) {
+  const node = ts14.factory.createTemplateHead(cooked, raw);
+  node.kind = ts14.SyntaxKind.TemplateMiddle;
+  return node;
+}
+function createTemplateTail(cooked, raw) {
+  const node = ts14.factory.createTemplateHead(cooked, raw);
+  node.kind = ts14.SyntaxKind.TemplateTail;
+  return node;
+}
+function attachComments(statement, leadingComments) {
+  for (const comment of leadingComments) {
+    const commentKind = comment.multiline ? ts14.SyntaxKind.MultiLineCommentTrivia : ts14.SyntaxKind.SingleLineCommentTrivia;
+    if (comment.multiline) {
+      ts14.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+    } else {
+      for (const line of comment.toString().split("\n")) {
+        ts14.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+      }
+    }
+  }
+}
+
+// bazel-out/darwin-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));
+}
+function translateStatement(statement, imports, options = {}) {
+  return statement.visitStatement(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new Context(true));
+}
+
 export {
   ErrorCode,
   COMPILER_ERRORS_WITH_GUIDES,
@@ -1640,8 +2467,23 @@ export {
   reflectObjectLiteral,
   DeferredSymbolTracker,
   Reference,
-  ModuleResolver
+  ModuleResolver,
+  Context,
+  ImportManager,
+  ExpressionTranslatorVisitor,
+  canEmitType,
+  TypeEmitter,
+  translateType,
+  translateExpression,
+  translateStatement
 };
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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
+ */
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -1649,4 +2491,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-EFMKZSXJ.js.map
+//# sourceMappingURL=chunk-3WRR7A6G.js.map