@angular/core 16.2.10 → 16.2.12

package/schematics/ng-generate/standalone-migration/bundle.js

@@ -21920,7 +21920,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("16.2.10");
+var VERSION2 = new Version("16.2.12");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -23362,7 +23362,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION = "12.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("16.2.10"));
+  definitionMap.set("version", literal("16.2.12"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -23433,7 +23433,7 @@ function createDirectiveDefinitionMap(meta) {
   const hasTransformFunctions = Object.values(meta.inputs).some((input) => input.transformFunction !== null);
   const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION2 : "14.0.0";
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("16.2.10"));
+  definitionMap.set("version", literal("16.2.12"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -23618,7 +23618,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION3 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION3));
-  definitionMap.set("version", literal("16.2.10"));
+  definitionMap.set("version", literal("16.2.12"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -23641,7 +23641,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("16.2.10"));
+  definitionMap.set("version", literal("16.2.12"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -23679,7 +23679,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("16.2.10"));
+  definitionMap.set("version", literal("16.2.12"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -23703,7 +23703,7 @@ function createNgModuleDefinitionMap(meta) {
     throw new Error("Invalid path! Local compilation mode should not get into the partial compilation path");
   }
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION6));
-  definitionMap.set("version", literal("16.2.10"));
+  definitionMap.set("version", literal("16.2.12"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -23738,7 +23738,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("16.2.10"));
+  definitionMap.set("version", literal("16.2.12"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
@@ -23755,7 +23755,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("16.2.10");
+var VERSION3 = new Version("16.2.12");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;
@@ -27853,7 +27853,7 @@ function compileInputTransformFields(inputs) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
-var import_typescript53 = __toESM(require("typescript"), 1);
+var import_typescript54 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.mjs
 var import_typescript33 = __toESM(require("typescript"), 1);
@@ -29359,7 +29359,7 @@ function containsErrors(diagnostics) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
-var import_typescript45 = __toESM(require("typescript"), 1);
+var import_typescript46 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/context.mjs
 var Context = class {
@@ -29644,8 +29644,83 @@ function createRange(span) {
   };
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_emitter.mjs
 var import_typescript42 = __toESM(require("typescript"), 1);
+var INELIGIBLE = {};
+function canEmitType(type, canEmit) {
+  return canEmitTypeWorker(type);
+  function canEmitTypeWorker(type2) {
+    return visitNode(type2) !== INELIGIBLE;
+  }
+  function visitNode(node) {
+    if (import_typescript42.default.isImportTypeNode(node)) {
+      return INELIGIBLE;
+    }
+    if (import_typescript42.default.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
+      return INELIGIBLE;
+    } else {
+      return import_typescript42.default.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 (import_typescript42.default.isImportTypeNode(node)) {
+          throw new Error("Unable to emit import type");
+        }
+        if (import_typescript42.default.isTypeReferenceNode(node)) {
+          return this.emitTypeReference(node);
+        } else if (import_typescript42.default.isLiteralExpression(node)) {
+          let clone;
+          if (import_typescript42.default.isStringLiteral(node)) {
+            clone = import_typescript42.default.factory.createStringLiteral(node.text);
+          } else if (import_typescript42.default.isNumericLiteral(node)) {
+            clone = import_typescript42.default.factory.createNumericLiteral(node.text);
+          } else if (import_typescript42.default.isBigIntLiteral(node)) {
+            clone = import_typescript42.default.factory.createBigIntLiteral(node.text);
+          } else if (import_typescript42.default.isNoSubstitutionTemplateLiteral(node)) {
+            clone = import_typescript42.default.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
+          } else if (import_typescript42.default.isRegularExpressionLiteral(node)) {
+            clone = import_typescript42.default.factory.createRegularExpressionLiteral(node.text);
+          } else {
+            throw new Error(`Unsupported literal kind ${import_typescript42.default.SyntaxKind[node.kind]}`);
+          }
+          import_typescript42.default.setTextRange(clone, { pos: -1, end: -1 });
+          return clone;
+        } else {
+          return import_typescript42.default.visitEachChild(node, visitNode, context);
+        }
+      };
+      return (node) => import_typescript42.default.visitNode(node, visitNode, import_typescript42.default.isTypeNode);
+    };
+    return import_typescript42.default.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 = import_typescript42.default.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
+    }
+    return import_typescript42.default.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
+  }
+};
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
+var import_typescript43 = __toESM(require("typescript"), 1);
 function translateType(type, contextFile, reflector, refEmitter, imports) {
   return type.visitType(new TypeTranslatorVisitor(imports, contextFile, reflector, refEmitter), new Context(false));
 }
@@ -29659,16 +29734,16 @@ var TypeTranslatorVisitor = class {
   visitBuiltinType(type, context) {
     switch (type.name) {
       case BuiltinTypeName.Bool:
-        return import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.BooleanKeyword);
+        return import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.BooleanKeyword);
       case BuiltinTypeName.Dynamic:
-        return import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.AnyKeyword);
+        return import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.AnyKeyword);
       case BuiltinTypeName.Int:
       case BuiltinTypeName.Number:
-        return import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.NumberKeyword);
+        return import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.NumberKeyword);
       case BuiltinTypeName.String:
-        return import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.StringKeyword);
+        return import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.StringKeyword);
       case BuiltinTypeName.None:
-        return import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.NeverKeyword);
+        return import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.NeverKeyword);
       default:
         throw new Error(`Unsupported builtin type: ${BuiltinTypeName[type.name]}`);
     }
@@ -29678,34 +29753,37 @@ var TypeTranslatorVisitor = class {
     if (type.typeParams === null) {
       return typeNode;
     }
-    if (!import_typescript42.default.isTypeReferenceNode(typeNode)) {
+    if (!import_typescript43.default.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 import_typescript42.default.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
+    return import_typescript43.default.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
   }
   visitArrayType(type, context) {
-    return import_typescript42.default.factory.createArrayTypeNode(this.translateType(type.of, context));
+    return import_typescript43.default.factory.createArrayTypeNode(this.translateType(type.of, context));
   }
   visitMapType(type, context) {
-    const parameter = import_typescript42.default.factory.createParameterDeclaration(void 0, void 0, "key", void 0, import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.StringKeyword));
-    const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.UnknownKeyword);
-    const indexSignature = import_typescript42.default.factory.createIndexSignature(void 0, [parameter], typeArgs);
-    return import_typescript42.default.factory.createTypeLiteralNode([indexSignature]);
+    const parameter = import_typescript43.default.factory.createParameterDeclaration(void 0, void 0, "key", void 0, import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.StringKeyword));
+    const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.UnknownKeyword);
+    const indexSignature = import_typescript43.default.factory.createIndexSignature(void 0, [parameter], typeArgs);
+    return import_typescript43.default.factory.createTypeLiteralNode([indexSignature]);
   }
   visitTransplantedType(ast, context) {
-    if (!import_typescript42.default.isTypeNode(ast.type)) {
+    const node = ast.type instanceof Reference2 ? ast.type.node : ast.type;
+    if (!import_typescript43.default.isTypeNode(node)) {
       throw new Error(`A TransplantedType must wrap a TypeNode`);
     }
-    return this.translateTransplantedTypeNode(ast.type, context);
+    const viaModule = ast.type instanceof Reference2 ? 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 import_typescript42.default.factory.createTypeQueryNode(import_typescript42.default.factory.createIdentifier(ast.name));
+    return import_typescript43.default.factory.createTypeQueryNode(import_typescript43.default.factory.createIdentifier(ast.name));
   }
   visitWriteVarExpr(expr, context) {
     throw new Error("Method not implemented.");
@@ -29727,15 +29805,15 @@ var TypeTranslatorVisitor = class {
   }
   visitLiteralExpr(ast, context) {
     if (ast.value === null) {
-      return import_typescript42.default.factory.createLiteralTypeNode(import_typescript42.default.factory.createNull());
+      return import_typescript43.default.factory.createLiteralTypeNode(import_typescript43.default.factory.createNull());
     } else if (ast.value === void 0) {
-      return import_typescript42.default.factory.createKeywordTypeNode(import_typescript42.default.SyntaxKind.UndefinedKeyword);
+      return import_typescript43.default.factory.createKeywordTypeNode(import_typescript43.default.SyntaxKind.UndefinedKeyword);
     } else if (typeof ast.value === "boolean") {
-      return import_typescript42.default.factory.createLiteralTypeNode(ast.value ? import_typescript42.default.factory.createTrue() : import_typescript42.default.factory.createFalse());
+      return import_typescript43.default.factory.createLiteralTypeNode(ast.value ? import_typescript43.default.factory.createTrue() : import_typescript43.default.factory.createFalse());
     } else if (typeof ast.value === "number") {
-      return import_typescript42.default.factory.createLiteralTypeNode(import_typescript42.default.factory.createNumericLiteral(ast.value));
+      return import_typescript43.default.factory.createLiteralTypeNode(import_typescript43.default.factory.createNumericLiteral(ast.value));
     } else {
-      return import_typescript42.default.factory.createLiteralTypeNode(import_typescript42.default.factory.createStringLiteral(ast.value));
+      return import_typescript43.default.factory.createLiteralTypeNode(import_typescript43.default.factory.createStringLiteral(ast.value));
     }
   }
   visitLocalizedString(ast, context) {
@@ -29746,10 +29824,10 @@ var TypeTranslatorVisitor = class {
       throw new Error(`Import unknown module or symbol`);
     }
     const { moduleImport, symbol } = this.imports.generateNamedImport(ast.value.moduleName, ast.value.name);
-    const symbolIdentifier = import_typescript42.default.factory.createIdentifier(symbol);
-    const typeName = moduleImport ? import_typescript42.default.factory.createQualifiedName(moduleImport, symbolIdentifier) : symbolIdentifier;
+    const symbolIdentifier = import_typescript43.default.factory.createIdentifier(symbol);
+    const typeName = moduleImport ? import_typescript43.default.factory.createQualifiedName(moduleImport, symbolIdentifier) : symbolIdentifier;
     const typeArguments = ast.typeParams !== null ? ast.typeParams.map((type) => this.translateType(type, context)) : void 0;
-    return import_typescript42.default.factory.createTypeReferenceNode(typeName, typeArguments);
+    return import_typescript43.default.factory.createTypeReferenceNode(typeName, typeArguments);
   }
   visitConditionalExpr(ast, context) {
     throw new Error("Method not implemented.");
@@ -29777,157 +29855,147 @@ var TypeTranslatorVisitor = class {
   }
   visitLiteralArrayExpr(ast, context) {
     const values = ast.entries.map((expr) => this.translateExpression(expr, context));
-    return import_typescript42.default.factory.createTupleTypeNode(values);
+    return import_typescript43.default.factory.createTupleTypeNode(values);
   }
   visitLiteralMapExpr(ast, context) {
     const entries = ast.entries.map((entry) => {
       const { key, quoted } = entry;
       const type = this.translateExpression(entry.value, context);
-      return import_typescript42.default.factory.createPropertySignature(
+      return import_typescript43.default.factory.createPropertySignature(
         void 0,
-        quoted ? import_typescript42.default.factory.createStringLiteral(key) : key,
+        quoted ? import_typescript43.default.factory.createStringLiteral(key) : key,
         void 0,
         type
       );
     });
-    return import_typescript42.default.factory.createTypeLiteralNode(entries);
+    return import_typescript43.default.factory.createTypeLiteralNode(entries);
   }
   visitCommaExpr(ast, context) {
     throw new Error("Method not implemented.");
   }
   visitWrappedNodeExpr(ast, context) {
     const node = ast.node;
-    if (import_typescript42.default.isEntityName(node)) {
-      return import_typescript42.default.factory.createTypeReferenceNode(node, void 0);
-    } else if (import_typescript42.default.isTypeNode(node)) {
+    if (import_typescript43.default.isEntityName(node)) {
+      return import_typescript43.default.factory.createTypeReferenceNode(node, void 0);
+    } else if (import_typescript43.default.isTypeNode(node)) {
       return node;
-    } else if (import_typescript42.default.isLiteralExpression(node)) {
-      return import_typescript42.default.factory.createLiteralTypeNode(node);
+    } else if (import_typescript43.default.isLiteralExpression(node)) {
+      return import_typescript43.default.factory.createLiteralTypeNode(node);
     } else {
-      throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${import_typescript42.default.SyntaxKind[node.kind]}`);
+      throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${import_typescript43.default.SyntaxKind[node.kind]}`);
     }
   }
   visitTypeofExpr(ast, context) {
     const typeNode = this.translateExpression(ast.expr, context);
-    if (!import_typescript42.default.isTypeReferenceNode(typeNode)) {
+    if (!import_typescript43.default.isTypeReferenceNode(typeNode)) {
       throw new Error(`The target of a typeof expression must be a type reference, but it was
-          ${import_typescript42.default.SyntaxKind[typeNode.kind]}`);
+          ${import_typescript43.default.SyntaxKind[typeNode.kind]}`);
     }
-    return import_typescript42.default.factory.createTypeQueryNode(typeNode.typeName);
+    return import_typescript43.default.factory.createTypeQueryNode(typeNode.typeName);
   }
   translateType(type, context) {
     const typeNode = type.visitType(this, context);
-    if (!import_typescript42.default.isTypeNode(typeNode)) {
-      throw new Error(`A Type must translate to a TypeNode, but was ${import_typescript42.default.SyntaxKind[typeNode.kind]}`);
+    if (!import_typescript43.default.isTypeNode(typeNode)) {
+      throw new Error(`A Type must translate to a TypeNode, but was ${import_typescript43.default.SyntaxKind[typeNode.kind]}`);
     }
     return typeNode;
   }
   translateExpression(expr, context) {
     const typeNode = expr.visitExpression(this, context);
-    if (!import_typescript42.default.isTypeNode(typeNode)) {
-      throw new Error(`An Expression must translate to a TypeNode, but was ${import_typescript42.default.SyntaxKind[typeNode.kind]}`);
+    if (!import_typescript43.default.isTypeNode(typeNode)) {
+      throw new Error(`An Expression must translate to a TypeNode, but was ${import_typescript43.default.SyntaxKind[typeNode.kind]}`);
     }
     return typeNode;
   }
-  translateTransplantedTypeReferenceNode(node, context) {
-    const declaration = this.reflector.getDeclarationOfIdentifier(node.typeName);
+  translateTypeReference(type, context, viaModule) {
+    const target = import_typescript43.default.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 ${node.typeName.text}`);
+      throw new Error(`Unable to statically determine the declaration file of type node ${target.text}`);
     }
-    const emittedType = this.refEmitter.emit(new Reference2(declaration.node), this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports);
-    assertSuccessfulReferenceEmit(emittedType, node, "type");
-    const result = emittedType.expression.visitExpression(this, context);
-    if (!import_typescript42.default.isTypeReferenceNode(result)) {
-      throw new Error(`Expected TypeReferenceNode when referencing the type for ${node.typeName.text}, but received ${import_typescript42.default.SyntaxKind[result.kind]}`);
+    let owningModule2 = viaModule;
+    if (declaration.viaModule !== null) {
+      owningModule2 = {
+        specifier: declaration.viaModule,
+        resolutionContext: type.getSourceFile().fileName
+      };
     }
-    if (node.typeArguments === void 0 || node.typeArguments.length === 0) {
-      return result;
+    const reference2 = new Reference2(declaration.node, owningModule2);
+    const emittedType = this.refEmitter.emit(reference2, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports);
+    assertSuccessfulReferenceEmit(emittedType, target, "type");
+    const typeNode = this.translateExpression(emittedType.expression, context);
+    if (!import_typescript43.default.isTypeReferenceNode(typeNode)) {
+      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${import_typescript43.default.SyntaxKind[typeNode.kind]}.`);
     }
-    const translatedArgs = node.typeArguments.map((arg) => this.translateTransplantedTypeNode(arg, context));
-    return import_typescript42.default.factory.updateTypeReferenceNode(result, result.typeName, import_typescript42.default.factory.createNodeArray(translatedArgs));
-  }
-  translateTransplantedTypeNode(rootNode, context) {
-    const factory8 = (transformContext) => (root) => {
-      const walk = (node) => {
-        if (import_typescript42.default.isTypeReferenceNode(node) && import_typescript42.default.isIdentifier(node.typeName)) {
-          const translated = this.translateTransplantedTypeReferenceNode(node, context);
-          if (translated !== node) {
-            return translated;
-          }
-        }
-        return import_typescript42.default.visitEachChild(node, walk, transformContext);
-      };
-      return import_typescript42.default.visitNode(root, walk);
-    };
-    return import_typescript42.default.transform(rootNode, [factory8]).transformed[0];
+    return typeNode;
   }
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.mjs
-var import_typescript43 = __toESM(require("typescript"), 1);
+var import_typescript44 = __toESM(require("typescript"), 1);
 var PureAnnotation;
 (function(PureAnnotation2) {
   PureAnnotation2["CLOSURE"] = "* @pureOrBreakMyCode ";
   PureAnnotation2["TERSER"] = "@__PURE__";
 })(PureAnnotation || (PureAnnotation = {}));
 var UNARY_OPERATORS3 = {
-  "+": import_typescript43.default.SyntaxKind.PlusToken,
-  "-": import_typescript43.default.SyntaxKind.MinusToken,
-  "!": import_typescript43.default.SyntaxKind.ExclamationToken
+  "+": import_typescript44.default.SyntaxKind.PlusToken,
+  "-": import_typescript44.default.SyntaxKind.MinusToken,
+  "!": import_typescript44.default.SyntaxKind.ExclamationToken
 };
 var BINARY_OPERATORS4 = {
-  "&&": import_typescript43.default.SyntaxKind.AmpersandAmpersandToken,
-  ">": import_typescript43.default.SyntaxKind.GreaterThanToken,
-  ">=": import_typescript43.default.SyntaxKind.GreaterThanEqualsToken,
-  "&": import_typescript43.default.SyntaxKind.AmpersandToken,
-  "/": import_typescript43.default.SyntaxKind.SlashToken,
-  "==": import_typescript43.default.SyntaxKind.EqualsEqualsToken,
-  "===": import_typescript43.default.SyntaxKind.EqualsEqualsEqualsToken,
-  "<": import_typescript43.default.SyntaxKind.LessThanToken,
-  "<=": import_typescript43.default.SyntaxKind.LessThanEqualsToken,
-  "-": import_typescript43.default.SyntaxKind.MinusToken,
-  "%": import_typescript43.default.SyntaxKind.PercentToken,
-  "*": import_typescript43.default.SyntaxKind.AsteriskToken,
-  "!=": import_typescript43.default.SyntaxKind.ExclamationEqualsToken,
-  "!==": import_typescript43.default.SyntaxKind.ExclamationEqualsEqualsToken,
-  "||": import_typescript43.default.SyntaxKind.BarBarToken,
-  "+": import_typescript43.default.SyntaxKind.PlusToken,
-  "??": import_typescript43.default.SyntaxKind.QuestionQuestionToken
+  "&&": import_typescript44.default.SyntaxKind.AmpersandAmpersandToken,
+  ">": import_typescript44.default.SyntaxKind.GreaterThanToken,
+  ">=": import_typescript44.default.SyntaxKind.GreaterThanEqualsToken,
+  "&": import_typescript44.default.SyntaxKind.AmpersandToken,
+  "/": import_typescript44.default.SyntaxKind.SlashToken,
+  "==": import_typescript44.default.SyntaxKind.EqualsEqualsToken,
+  "===": import_typescript44.default.SyntaxKind.EqualsEqualsEqualsToken,
+  "<": import_typescript44.default.SyntaxKind.LessThanToken,
+  "<=": import_typescript44.default.SyntaxKind.LessThanEqualsToken,
+  "-": import_typescript44.default.SyntaxKind.MinusToken,
+  "%": import_typescript44.default.SyntaxKind.PercentToken,
+  "*": import_typescript44.default.SyntaxKind.AsteriskToken,
+  "!=": import_typescript44.default.SyntaxKind.ExclamationEqualsToken,
+  "!==": import_typescript44.default.SyntaxKind.ExclamationEqualsEqualsToken,
+  "||": import_typescript44.default.SyntaxKind.BarBarToken,
+  "+": import_typescript44.default.SyntaxKind.PlusToken,
+  "??": import_typescript44.default.SyntaxKind.QuestionQuestionToken
 };
 var VAR_TYPES = {
-  "const": import_typescript43.default.NodeFlags.Const,
-  "let": import_typescript43.default.NodeFlags.Let,
-  "var": import_typescript43.default.NodeFlags.None
+  "const": import_typescript44.default.NodeFlags.Const,
+  "let": import_typescript44.default.NodeFlags.Let,
+  "var": import_typescript44.default.NodeFlags.None
 };
 var TypeScriptAstFactory = class {
   constructor(annotateForClosureCompiler) {
     this.annotateForClosureCompiler = annotateForClosureCompiler;
     this.externalSourceFiles = /* @__PURE__ */ new Map();
     this.attachComments = attachComments;
-    this.createArrayLiteral = import_typescript43.default.factory.createArrayLiteralExpression;
-    this.createElementAccess = import_typescript43.default.factory.createElementAccessExpression;
-    this.createExpressionStatement = import_typescript43.default.factory.createExpressionStatement;
-    this.createIdentifier = import_typescript43.default.factory.createIdentifier;
-    this.createParenthesizedExpression = import_typescript43.default.factory.createParenthesizedExpression;
-    this.createPropertyAccess = import_typescript43.default.factory.createPropertyAccessExpression;
-    this.createThrowStatement = import_typescript43.default.factory.createThrowStatement;
-    this.createTypeOfExpression = import_typescript43.default.factory.createTypeOfExpression;
+    this.createArrayLiteral = import_typescript44.default.factory.createArrayLiteralExpression;
+    this.createElementAccess = import_typescript44.default.factory.createElementAccessExpression;
+    this.createExpressionStatement = import_typescript44.default.factory.createExpressionStatement;
+    this.createIdentifier = import_typescript44.default.factory.createIdentifier;
+    this.createParenthesizedExpression = import_typescript44.default.factory.createParenthesizedExpression;
+    this.createPropertyAccess = import_typescript44.default.factory.createPropertyAccessExpression;
+    this.createThrowStatement = import_typescript44.default.factory.createThrowStatement;
+    this.createTypeOfExpression = import_typescript44.default.factory.createTypeOfExpression;
   }
   createAssignment(target, value) {
-    return import_typescript43.default.factory.createBinaryExpression(target, import_typescript43.default.SyntaxKind.EqualsToken, value);
+    return import_typescript44.default.factory.createBinaryExpression(target, import_typescript44.default.SyntaxKind.EqualsToken, value);
   }
   createBinaryExpression(leftOperand, operator, rightOperand) {
-    return import_typescript43.default.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS4[operator], rightOperand);
+    return import_typescript44.default.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS4[operator], rightOperand);
   }
   createBlock(body) {
-    return import_typescript43.default.factory.createBlock(body);
+    return import_typescript44.default.factory.createBlock(body);
   }
   createCallExpression(callee, args, pure) {
-    const call2 = import_typescript43.default.factory.createCallExpression(callee, void 0, args);
+    const call2 = import_typescript44.default.factory.createCallExpression(callee, void 0, args);
     if (pure) {
-      import_typescript43.default.addSyntheticLeadingComment(
+      import_typescript44.default.addSyntheticLeadingComment(
         call2,
-        import_typescript43.default.SyntaxKind.MultiLineCommentTrivia,
+        import_typescript44.default.SyntaxKind.MultiLineCommentTrivia,
         this.annotateForClosureCompiler ? PureAnnotation.CLOSURE : PureAnnotation.TERSER,
         false
       );
@@ -29935,58 +30003,58 @@ var TypeScriptAstFactory = class {
     return call2;
   }
   createConditional(condition, whenTrue, whenFalse) {
-    return import_typescript43.default.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
+    return import_typescript44.default.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
   }
   createDynamicImport(url) {
-    return import_typescript43.default.factory.createCallExpression(
-      import_typescript43.default.factory.createToken(import_typescript43.default.SyntaxKind.ImportKeyword),
+    return import_typescript44.default.factory.createCallExpression(
+      import_typescript44.default.factory.createToken(import_typescript44.default.SyntaxKind.ImportKeyword),
       void 0,
-      [import_typescript43.default.factory.createStringLiteral(url)]
+      [import_typescript44.default.factory.createStringLiteral(url)]
     );
   }
   createFunctionDeclaration(functionName, parameters, body) {
-    if (!import_typescript43.default.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript43.default.SyntaxKind[body.kind]}.`);
+    if (!import_typescript44.default.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript44.default.SyntaxKind[body.kind]}.`);
     }
-    return import_typescript43.default.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => import_typescript43.default.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return import_typescript44.default.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => import_typescript44.default.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
   }
   createFunctionExpression(functionName, parameters, body) {
-    if (!import_typescript43.default.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript43.default.SyntaxKind[body.kind]}.`);
+    if (!import_typescript44.default.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript44.default.SyntaxKind[body.kind]}.`);
     }
-    return import_typescript43.default.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => import_typescript43.default.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return import_typescript44.default.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => import_typescript44.default.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
   }
   createIfStatement(condition, thenStatement, elseStatement) {
-    return import_typescript43.default.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
+    return import_typescript44.default.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
   }
   createLiteral(value) {
     if (value === void 0) {
-      return import_typescript43.default.factory.createIdentifier("undefined");
+      return import_typescript44.default.factory.createIdentifier("undefined");
     } else if (value === null) {
-      return import_typescript43.default.factory.createNull();
+      return import_typescript44.default.factory.createNull();
     } else if (typeof value === "boolean") {
-      return value ? import_typescript43.default.factory.createTrue() : import_typescript43.default.factory.createFalse();
+      return value ? import_typescript44.default.factory.createTrue() : import_typescript44.default.factory.createFalse();
     } else if (typeof value === "number") {
-      return import_typescript43.default.factory.createNumericLiteral(value);
+      return import_typescript44.default.factory.createNumericLiteral(value);
     } else {
-      return import_typescript43.default.factory.createStringLiteral(value);
+      return import_typescript44.default.factory.createStringLiteral(value);
     }
   }
   createNewExpression(expression, args) {
-    return import_typescript43.default.factory.createNewExpression(expression, void 0, args);
+    return import_typescript44.default.factory.createNewExpression(expression, void 0, args);
   }
   createObjectLiteral(properties) {
-    return import_typescript43.default.factory.createObjectLiteralExpression(properties.map((prop) => import_typescript43.default.factory.createPropertyAssignment(prop.quoted ? import_typescript43.default.factory.createStringLiteral(prop.propertyName) : import_typescript43.default.factory.createIdentifier(prop.propertyName), prop.value)));
+    return import_typescript44.default.factory.createObjectLiteralExpression(properties.map((prop) => import_typescript44.default.factory.createPropertyAssignment(prop.quoted ? import_typescript44.default.factory.createStringLiteral(prop.propertyName) : import_typescript44.default.factory.createIdentifier(prop.propertyName), prop.value)));
   }
   createReturnStatement(expression) {
-    return import_typescript43.default.factory.createReturnStatement(expression != null ? expression : void 0);
+    return import_typescript44.default.factory.createReturnStatement(expression != null ? expression : void 0);
   }
   createTaggedTemplate(tag, template2) {
     let templateLiteral;
     const length = template2.elements.length;
     const head = template2.elements[0];
     if (length === 1) {
-      templateLiteral = import_typescript43.default.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+      templateLiteral = import_typescript44.default.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
     } else {
       const spans = [];
       for (let i = 1; i < length - 1; i++) {
@@ -29995,7 +30063,7 @@ var TypeScriptAstFactory = class {
         if (range !== null) {
           this.setSourceMapRange(middle, range);
         }
-        spans.push(import_typescript43.default.factory.createTemplateSpan(template2.expressions[i - 1], middle));
+        spans.push(import_typescript44.default.factory.createTemplateSpan(template2.expressions[i - 1], middle));
       }
       const resolvedExpression = template2.expressions[length - 2];
       const templatePart = template2.elements[length - 1];
@@ -30003,19 +30071,19 @@ var TypeScriptAstFactory = class {
       if (templatePart.range !== null) {
         this.setSourceMapRange(templateTail, templatePart.range);
       }
-      spans.push(import_typescript43.default.factory.createTemplateSpan(resolvedExpression, templateTail));
-      templateLiteral = import_typescript43.default.factory.createTemplateExpression(import_typescript43.default.factory.createTemplateHead(head.cooked, head.raw), spans);
+      spans.push(import_typescript44.default.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = import_typescript44.default.factory.createTemplateExpression(import_typescript44.default.factory.createTemplateHead(head.cooked, head.raw), spans);
     }
     if (head.range !== null) {
       this.setSourceMapRange(templateLiteral, head.range);
     }
-    return import_typescript43.default.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
+    return import_typescript44.default.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
   }
   createUnaryExpression(operator, operand) {
-    return import_typescript43.default.factory.createPrefixUnaryExpression(UNARY_OPERATORS3[operator], operand);
+    return import_typescript44.default.factory.createPrefixUnaryExpression(UNARY_OPERATORS3[operator], operand);
   }
   createVariableDeclaration(variableName, initializer, type) {
-    return import_typescript43.default.factory.createVariableStatement(void 0, import_typescript43.default.factory.createVariableDeclarationList([import_typescript43.default.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
+    return import_typescript44.default.factory.createVariableStatement(void 0, import_typescript44.default.factory.createVariableDeclarationList([import_typescript44.default.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
   }
   setSourceMapRange(node, sourceMapRange) {
     if (sourceMapRange === null) {
@@ -30023,31 +30091,31 @@ var TypeScriptAstFactory = class {
     }
     const url = sourceMapRange.url;
     if (!this.externalSourceFiles.has(url)) {
-      this.externalSourceFiles.set(url, import_typescript43.default.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+      this.externalSourceFiles.set(url, import_typescript44.default.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
     }
     const source = this.externalSourceFiles.get(url);
-    import_typescript43.default.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
+    import_typescript44.default.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
     return node;
   }
 };
 function createTemplateMiddle(cooked, raw) {
-  const node = import_typescript43.default.factory.createTemplateHead(cooked, raw);
-  node.kind = import_typescript43.default.SyntaxKind.TemplateMiddle;
+  const node = import_typescript44.default.factory.createTemplateHead(cooked, raw);
+  node.kind = import_typescript44.default.SyntaxKind.TemplateMiddle;
   return node;
 }
 function createTemplateTail(cooked, raw) {
-  const node = import_typescript43.default.factory.createTemplateHead(cooked, raw);
-  node.kind = import_typescript43.default.SyntaxKind.TemplateTail;
+  const node = import_typescript44.default.factory.createTemplateHead(cooked, raw);
+  node.kind = import_typescript44.default.SyntaxKind.TemplateTail;
   return node;
 }
 function attachComments(statement, leadingComments) {
   for (const comment of leadingComments) {
-    const commentKind = comment.multiline ? import_typescript43.default.SyntaxKind.MultiLineCommentTrivia : import_typescript43.default.SyntaxKind.SingleLineCommentTrivia;
+    const commentKind = comment.multiline ? import_typescript44.default.SyntaxKind.MultiLineCommentTrivia : import_typescript44.default.SyntaxKind.SingleLineCommentTrivia;
     if (comment.multiline) {
-      import_typescript43.default.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+      import_typescript44.default.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
     } else {
       for (const line of comment.toString().split("\n")) {
-        import_typescript43.default.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+        import_typescript44.default.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
       }
     }
   }
@@ -30062,28 +30130,28 @@ function translateStatement(statement, imports, options = {}) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/utils.mjs
-var import_typescript44 = __toESM(require("typescript"), 1);
+var import_typescript45 = __toESM(require("typescript"), 1);
 function addImports(importManager, sf, extraStatements = []) {
   const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
-    const qualifier = import_typescript44.default.factory.createIdentifier(i.qualifier.text);
-    const importClause = import_typescript44.default.factory.createImportClause(
+    const qualifier = import_typescript45.default.factory.createIdentifier(i.qualifier.text);
+    const importClause = import_typescript45.default.factory.createImportClause(
       false,
       void 0,
-      import_typescript44.default.factory.createNamespaceImport(qualifier)
+      import_typescript45.default.factory.createNamespaceImport(qualifier)
     );
-    const decl = import_typescript44.default.factory.createImportDeclaration(
+    const decl = import_typescript45.default.factory.createImportDeclaration(
       void 0,
       importClause,
-      import_typescript44.default.factory.createStringLiteral(i.specifier)
+      import_typescript45.default.factory.createStringLiteral(i.specifier)
     );
-    import_typescript44.default.setOriginalNode(i.qualifier, decl);
+    import_typescript45.default.setOriginalNode(i.qualifier, decl);
     return decl;
   });
   const existingImports = sf.statements.filter((stmt) => isImportStatement(stmt));
   const body = sf.statements.filter((stmt) => !isImportStatement(stmt));
   if (addedImports.length > 0) {
-    const fileoverviewAnchorStmt = import_typescript44.default.factory.createNotEmittedStatement(sf);
-    return import_typescript44.default.factory.updateSourceFile(sf, import_typescript44.default.factory.createNodeArray([
+    const fileoverviewAnchorStmt = import_typescript45.default.factory.createNotEmittedStatement(sf);
+    return import_typescript45.default.factory.updateSourceFile(sf, import_typescript45.default.factory.createNodeArray([
       fileoverviewAnchorStmt,
       ...existingImports,
       ...addedImports,
@@ -30094,7 +30162,7 @@ function addImports(importManager, sf, extraStatements = []) {
   return sf;
 }
 function isImportStatement(stmt) {
-  return import_typescript44.default.isImportDeclaration(stmt) || import_typescript44.default.isImportEqualsDeclaration(stmt) || import_typescript44.default.isNamespaceImport(stmt);
+  return import_typescript45.default.isImportDeclaration(stmt) || import_typescript45.default.isImportEqualsDeclaration(stmt) || import_typescript45.default.isNamespaceImport(stmt);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
@@ -30112,7 +30180,7 @@ var DtsTransformRegistry = class {
     if (!sf.isDeclarationFile) {
       return null;
     }
-    const originalSf = import_typescript45.default.getOriginalNode(sf);
+    const originalSf = import_typescript46.default.getOriginalNode(sf);
     let transforms = null;
     if (this.ivyDeclarationTransforms.has(originalSf)) {
       transforms = [];
@@ -30125,7 +30193,7 @@ function declarationTransformFactory(transformRegistry, reflector, refEmitter, i
   return (context) => {
     const transformer = new DtsTransformer(context, reflector, refEmitter, importRewriter, importPrefix);
     return (fileOrBundle) => {
-      if (import_typescript45.default.isBundle(fileOrBundle)) {
+      if (import_typescript46.default.isBundle(fileOrBundle)) {
         return fileOrBundle;
       }
       const transforms = transformRegistry.getAllTransforms(fileOrBundle);
@@ -30147,15 +30215,15 @@ var DtsTransformer = class {
   transform(sf, transforms) {
     const imports = new ImportManager(this.importRewriter, this.importPrefix);
     const visitor = (node) => {
-      if (import_typescript45.default.isClassDeclaration(node)) {
+      if (import_typescript46.default.isClassDeclaration(node)) {
         return this.transformClassDeclaration(node, transforms, imports);
-      } else if (import_typescript45.default.isFunctionDeclaration(node)) {
+      } else if (import_typescript46.default.isFunctionDeclaration(node)) {
         return this.transformFunctionDeclaration(node, transforms, imports);
       } else {
-        return import_typescript45.default.visitEachChild(node, visitor, this.ctx);
+        return import_typescript46.default.visitEachChild(node, visitor, this.ctx);
       }
     };
-    sf = import_typescript45.default.visitNode(sf, visitor, import_typescript45.default.isSourceFile) || sf;
+    sf = import_typescript46.default.visitNode(sf, visitor, import_typescript46.default.isSourceFile) || sf;
     return addImports(imports, sf);
   }
   transformClassDeclaration(clazz, transforms, imports) {
@@ -30183,7 +30251,7 @@ var DtsTransformer = class {
       }
     }
     if (elementsChanged && clazz === newClazz) {
-      newClazz = import_typescript45.default.factory.updateClassDeclaration(
+      newClazz = import_typescript46.default.factory.updateClassDeclaration(
         clazz,
         clazz.modifiers,
         clazz.name,
@@ -30212,16 +30280,16 @@ var IvyDeclarationDtsTransform = class {
     this.declarationFields.set(decl, fields);
   }
   transformClass(clazz, members, reflector, refEmitter, imports) {
-    const original = import_typescript45.default.getOriginalNode(clazz);
+    const original = import_typescript46.default.getOriginalNode(clazz);
     if (!this.declarationFields.has(original)) {
       return clazz;
     }
     const fields = this.declarationFields.get(original);
     const newMembers = fields.map((decl) => {
-      const modifiers = [import_typescript45.default.factory.createModifier(import_typescript45.default.SyntaxKind.StaticKeyword)];
+      const modifiers = [import_typescript46.default.factory.createModifier(import_typescript46.default.SyntaxKind.StaticKeyword)];
       const typeRef = translateType(decl.type, original.getSourceFile(), reflector, refEmitter, imports);
       markForEmitAsSingleLine(typeRef);
-      return import_typescript45.default.factory.createPropertyDeclaration(
+      return import_typescript46.default.factory.createPropertyDeclaration(
         modifiers,
         decl.name,
         void 0,
@@ -30229,7 +30297,7 @@ var IvyDeclarationDtsTransform = class {
         void 0
       );
     });
-    return import_typescript45.default.factory.updateClassDeclaration(
+    return import_typescript46.default.factory.updateClassDeclaration(
       clazz,
       clazz.modifiers,
       clazz.name,
@@ -30240,15 +30308,15 @@ var IvyDeclarationDtsTransform = class {
   }
 };
 function markForEmitAsSingleLine(node) {
-  import_typescript45.default.setEmitFlags(node, import_typescript45.default.EmitFlags.SingleLine);
-  import_typescript45.default.forEachChild(node, markForEmitAsSingleLine);
+  import_typescript46.default.setEmitFlags(node, import_typescript46.default.EmitFlags.SingleLine);
+  import_typescript46.default.forEachChild(node, markForEmitAsSingleLine);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
-var import_typescript47 = __toESM(require("typescript"), 1);
+var import_typescript48 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/visitor.mjs
-var import_typescript46 = __toESM(require("typescript"), 1);
+var import_typescript47 = __toESM(require("typescript"), 1);
 function visit(node, visitor, context) {
   return visitor._visit(node, context);
 }
@@ -30272,13 +30340,13 @@ var Visitor = class {
   }
   _visit(node, context) {
     let visitedNode = null;
-    node = import_typescript46.default.visitEachChild(node, (child) => child && this._visit(child, context), context);
-    if (import_typescript46.default.isClassDeclaration(node)) {
+    node = import_typescript47.default.visitEachChild(node, (child) => child && this._visit(child, context), context);
+    if (import_typescript47.default.isClassDeclaration(node)) {
       visitedNode = this._visitListEntryNode(node, (node2) => this.visitClassDeclaration(node2));
     } else {
       visitedNode = this.visitOtherNode(node);
     }
-    if (visitedNode && (import_typescript46.default.isBlock(visitedNode) || import_typescript46.default.isSourceFile(visitedNode))) {
+    if (visitedNode && (import_typescript47.default.isBlock(visitedNode) || import_typescript47.default.isSourceFile(visitedNode))) {
       visitedNode = this._maybeProcessStatements(visitedNode);
     }
     return visitedNode;
@@ -30299,11 +30367,11 @@ var Visitor = class {
         this._after.delete(stmt);
       }
     });
-    const statementsArray = import_typescript46.default.factory.createNodeArray(newStatements, node.statements.hasTrailingComma);
-    if (import_typescript46.default.isBlock(node)) {
-      return import_typescript46.default.factory.updateBlock(node, statementsArray);
+    const statementsArray = import_typescript47.default.factory.createNodeArray(newStatements, node.statements.hasTrailingComma);
+    if (import_typescript47.default.isBlock(node)) {
+      return import_typescript47.default.factory.updateBlock(node, statementsArray);
     } else {
-      return import_typescript46.default.factory.updateSourceFile(node, statementsArray, node.isDeclarationFile, node.referencedFiles, node.typeReferenceDirectives, node.hasNoDefaultLib, node.libReferenceDirectives);
+      return import_typescript47.default.factory.updateSourceFile(node, statementsArray, node.isDeclarationFile, node.referencedFiles, node.typeReferenceDirectives, node.hasNoDefaultLib, node.libReferenceDirectives);
     }
   }
 };
@@ -30367,11 +30435,11 @@ var IvyTransformationVisitor = class extends Visitor {
         continue;
       }
       const exprNode = translateExpression(field.initializer, this.importManager, translateOptions);
-      const property2 = import_typescript47.default.factory.createPropertyDeclaration([import_typescript47.default.factory.createToken(import_typescript47.default.SyntaxKind.StaticKeyword)], field.name, void 0, void 0, exprNode);
+      const property2 = import_typescript48.default.factory.createPropertyDeclaration([import_typescript48.default.factory.createToken(import_typescript48.default.SyntaxKind.StaticKeyword)], field.name, void 0, void 0, exprNode);
       if (this.isClosureCompilerEnabled) {
-        import_typescript47.default.addSyntheticLeadingComment(
+        import_typescript48.default.addSyntheticLeadingComment(
           property2,
-          import_typescript47.default.SyntaxKind.MultiLineCommentTrivia,
+          import_typescript48.default.SyntaxKind.MultiLineCommentTrivia,
           "* @nocollapse ",
           false
         );
@@ -30379,13 +30447,13 @@ var IvyTransformationVisitor = class extends Visitor {
       field.statements.map((stmt) => translateStatement(stmt, this.importManager, translateOptions)).forEach((stmt) => statements.push(stmt));
       members.push(property2);
     }
-    const filteredDecorators = maybeFilterDecorator(import_typescript47.default.getDecorators(node), this.compilation.decoratorsFor(node));
-    const nodeModifiers = import_typescript47.default.getModifiers(node);
+    const filteredDecorators = maybeFilterDecorator(import_typescript48.default.getDecorators(node), this.compilation.decoratorsFor(node));
+    const nodeModifiers = import_typescript48.default.getModifiers(node);
     let updatedModifiers;
     if ((filteredDecorators == null ? void 0 : filteredDecorators.length) || (nodeModifiers == null ? void 0 : nodeModifiers.length)) {
       updatedModifiers = [...filteredDecorators || [], ...nodeModifiers || []];
     }
-    node = import_typescript47.default.factory.updateClassDeclaration(
+    node = import_typescript48.default.factory.updateClassDeclaration(
       node,
       updatedModifiers,
       node.name,
@@ -30396,7 +30464,7 @@ var IvyTransformationVisitor = class extends Visitor {
     return { node, after: statements };
   }
   visitOtherNode(node) {
-    if (import_typescript47.default.isImportDeclaration(node) && this.deferrableImports.has(node)) {
+    if (import_typescript48.default.isImportDeclaration(node) && this.deferrableImports.has(node)) {
       return null;
     }
     return node;
@@ -30414,7 +30482,7 @@ var IvyTransformationVisitor = class extends Visitor {
     }
   }
   _nonCoreDecoratorsOnly(node) {
-    const decorators = import_typescript47.default.getDecorators(node);
+    const decorators = import_typescript48.default.getDecorators(node);
     if (decorators === void 0) {
       return void 0;
     }
@@ -30431,22 +30499,22 @@ var IvyTransformationVisitor = class extends Visitor {
     return nodeArrayFromDecoratorsArray(filtered);
   }
   _stripAngularDecorators(node) {
-    const modifiers = import_typescript47.default.canHaveModifiers(node) ? import_typescript47.default.getModifiers(node) : void 0;
-    const nonCoreDecorators = import_typescript47.default.canHaveDecorators(node) ? this._nonCoreDecoratorsOnly(node) : void 0;
+    const modifiers = import_typescript48.default.canHaveModifiers(node) ? import_typescript48.default.getModifiers(node) : void 0;
+    const nonCoreDecorators = import_typescript48.default.canHaveDecorators(node) ? this._nonCoreDecoratorsOnly(node) : void 0;
     const combinedModifiers = [...nonCoreDecorators || [], ...modifiers || []];
-    if (import_typescript47.default.isParameter(node)) {
-      node = import_typescript47.default.factory.updateParameterDeclaration(node, combinedModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
-    } else if (import_typescript47.default.isMethodDeclaration(node)) {
-      node = import_typescript47.default.factory.updateMethodDeclaration(node, combinedModifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
-    } else if (import_typescript47.default.isPropertyDeclaration(node)) {
-      node = import_typescript47.default.factory.updatePropertyDeclaration(node, combinedModifiers, node.name, node.questionToken, node.type, node.initializer);
-    } else if (import_typescript47.default.isGetAccessor(node)) {
-      node = import_typescript47.default.factory.updateGetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.type, node.body);
-    } else if (import_typescript47.default.isSetAccessor(node)) {
-      node = import_typescript47.default.factory.updateSetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.body);
-    } else if (import_typescript47.default.isConstructorDeclaration(node)) {
+    if (import_typescript48.default.isParameter(node)) {
+      node = import_typescript48.default.factory.updateParameterDeclaration(node, combinedModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+    } else if (import_typescript48.default.isMethodDeclaration(node)) {
+      node = import_typescript48.default.factory.updateMethodDeclaration(node, combinedModifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
+    } else if (import_typescript48.default.isPropertyDeclaration(node)) {
+      node = import_typescript48.default.factory.updatePropertyDeclaration(node, combinedModifiers, node.name, node.questionToken, node.type, node.initializer);
+    } else if (import_typescript48.default.isGetAccessor(node)) {
+      node = import_typescript48.default.factory.updateGetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.type, node.body);
+    } else if (import_typescript48.default.isSetAccessor(node)) {
+      node = import_typescript48.default.factory.updateSetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.body);
+    } else if (import_typescript48.default.isConstructorDeclaration(node)) {
       const parameters = node.parameters.map((param) => this._stripAngularDecorators(param));
-      node = import_typescript47.default.factory.updateConstructorDeclaration(node, modifiers, parameters, node.body);
+      node = import_typescript48.default.factory.updateConstructorDeclaration(node, modifiers, parameters, node.body);
     }
     return node;
   }
@@ -30458,7 +30526,7 @@ function transformIvySourceFile(compilation, context, reflector, importRewriter,
   visit(file, compilationVisitor, context);
   const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore, compilationVisitor.deferrableImports);
   let sf = visit(file, transformationVisitor, context);
-  const downlevelTranslatedCode = getLocalizeCompileTarget(context) < import_typescript47.default.ScriptTarget.ES2015;
+  const downlevelTranslatedCode = getLocalizeCompileTarget(context) < import_typescript48.default.ScriptTarget.ES2015;
   const constants = constantPool.statements.map((stmt) => translateStatement(stmt, importManager, {
     recordWrappedNode,
     downlevelTaggedTemplates: downlevelTranslatedCode,
@@ -30473,17 +30541,17 @@ function transformIvySourceFile(compilation, context, reflector, importRewriter,
   return sf;
 }
 function getLocalizeCompileTarget(context) {
-  const target = context.getCompilerOptions().target || import_typescript47.default.ScriptTarget.ES2015;
-  return target !== import_typescript47.default.ScriptTarget.JSON ? target : import_typescript47.default.ScriptTarget.ES2015;
+  const target = context.getCompilerOptions().target || import_typescript48.default.ScriptTarget.ES2015;
+  return target !== import_typescript48.default.ScriptTarget.JSON ? target : import_typescript48.default.ScriptTarget.ES2015;
 }
 function getFileOverviewComment(statements) {
   if (statements.length > 0) {
     const host = statements[0];
     let trailing = false;
-    let comments = import_typescript47.default.getSyntheticLeadingComments(host);
+    let comments = import_typescript48.default.getSyntheticLeadingComments(host);
     if (!comments || comments.length === 0) {
       trailing = true;
-      comments = import_typescript47.default.getSyntheticTrailingComments(host);
+      comments = import_typescript48.default.getSyntheticTrailingComments(host);
     }
     if (comments && comments.length > 0 && CLOSURE_FILE_OVERVIEW_REGEXP.test(comments[0].text)) {
       return { comments, host, trailing };
@@ -30495,22 +30563,22 @@ function setFileOverviewComment(sf, fileoverview) {
   const { comments, host, trailing } = fileoverview;
   if (sf.statements.length > 0 && host !== sf.statements[0]) {
     if (trailing) {
-      import_typescript47.default.setSyntheticTrailingComments(host, void 0);
+      import_typescript48.default.setSyntheticTrailingComments(host, void 0);
     } else {
-      import_typescript47.default.setSyntheticLeadingComments(host, void 0);
+      import_typescript48.default.setSyntheticLeadingComments(host, void 0);
     }
-    import_typescript47.default.setSyntheticLeadingComments(sf.statements[0], comments);
+    import_typescript48.default.setSyntheticLeadingComments(sf.statements[0], comments);
   }
 }
 function maybeFilterDecorator(decorators, toRemove) {
   if (decorators === void 0) {
     return void 0;
   }
-  const filtered = decorators.filter((dec) => toRemove.find((decToRemove) => import_typescript47.default.getOriginalNode(dec) === decToRemove) === void 0);
+  const filtered = decorators.filter((dec) => toRemove.find((decToRemove) => import_typescript48.default.getOriginalNode(dec) === decToRemove) === void 0);
   if (filtered.length === 0) {
     return void 0;
   }
-  return import_typescript47.default.factory.createNodeArray(filtered);
+  return import_typescript48.default.factory.createNodeArray(filtered);
 }
 function isFromAngularCore(decorator) {
   return decorator.import !== null && decorator.import.from === "@angular/core";
@@ -30524,7 +30592,7 @@ function createRecorderFn(defaultImportTracker) {
   };
 }
 function nodeArrayFromDecoratorsArray(decorators) {
-  const array = import_typescript47.default.factory.createNodeArray(decorators);
+  const array = import_typescript48.default.factory.createNodeArray(decorators);
   if (array.length > 0) {
     array.pos = decorators[0].pos;
     array.end = decorators[decorators.length - 1].end;
@@ -30533,7 +30601,7 @@ function nodeArrayFromDecoratorsArray(decorators) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.mjs
-var import_typescript48 = __toESM(require("typescript"), 1);
+var import_typescript49 = __toESM(require("typescript"), 1);
 var EMPTY_OBJECT = {};
 var QUERY_TYPES = /* @__PURE__ */ new Set([
   "ContentChild",
@@ -30549,7 +30617,7 @@ function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, refEmi
     throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, `Incorrect number of arguments to @${decorator.name} decorator`);
   } else {
     const meta = unwrapExpression(decorator.args[0]);
-    if (!import_typescript48.default.isObjectLiteralExpression(meta)) {
+    if (!import_typescript49.default.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `@${decorator.name} argument must be an object literal`);
     }
     directive = reflectObjectLiteral(meta);
@@ -30687,7 +30755,7 @@ function extractQueryMetadata(exprNode, name, args, propertyName, reflector, eva
   let emitDistinctChangesOnly = emitDistinctChangesOnlyDefaultValue;
   if (args.length === 2) {
     const optionsExpr = unwrapExpression(args[1]);
-    if (!import_typescript48.default.isObjectLiteralExpression(optionsExpr)) {
+    if (!import_typescript49.default.isObjectLiteralExpression(optionsExpr)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, optionsExpr, `@${name} options must be an object literal`);
     }
     const options = reflectObjectLiteral(optionsExpr);
@@ -30782,16 +30850,16 @@ function extractHostBindings2(members, evaluator, coreModule, metadata) {
 }
 function extractQueriesFromDecorator(queryData, reflector, evaluator, isCore) {
   const content = [], view = [];
-  if (!import_typescript48.default.isObjectLiteralExpression(queryData)) {
+  if (!import_typescript49.default.isObjectLiteralExpression(queryData)) {
     throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, "Decorator queries metadata must be an object literal");
   }
   reflectObjectLiteral(queryData).forEach((queryExpr, propertyName) => {
     queryExpr = unwrapExpression(queryExpr);
-    if (!import_typescript48.default.isNewExpression(queryExpr)) {
+    if (!import_typescript49.default.isNewExpression(queryExpr)) {
       throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, "Decorator query metadata must be an instance of a query type");
     }
-    const queryType = import_typescript48.default.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
-    if (!import_typescript48.default.isIdentifier(queryType)) {
+    const queryType = import_typescript49.default.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
+    if (!import_typescript49.default.isIdentifier(queryType)) {
       throw new FatalDiagnosticError(ErrorCode.VALUE_HAS_WRONG_TYPE, queryData, "Decorator query metadata must be an instance of a query type");
     }
     const type = reflector.getImportOfIdentifier(queryType);
@@ -30973,7 +31041,10 @@ function parseInputTransformFunction(clazz, classPropertyName, value, reflector,
   }
   const firstParam = ((_a2 = definition.parameters[0]) == null ? void 0 : _a2.name) === "this" ? definition.parameters[1] : definition.parameters[0];
   if (!firstParam) {
-    return { node, type: import_typescript48.default.factory.createKeywordTypeNode(import_typescript48.default.SyntaxKind.UnknownKeyword) };
+    return {
+      node,
+      type: new Reference2(import_typescript49.default.factory.createKeywordTypeNode(import_typescript49.default.SyntaxKind.UnknownKeyword))
+    };
   }
   if (!firstParam.type) {
     throw createValueHasWrongTypeError(value.node, value, "Input transform function first parameter must have a type");
@@ -30982,11 +31053,12 @@ function parseInputTransformFunction(clazz, classPropertyName, value, reflector,
     throw createValueHasWrongTypeError(value.node, value, "Input transform function first parameter cannot be a spread parameter");
   }
   assertEmittableInputType(firstParam.type, clazz.getSourceFile(), reflector, refEmitter);
-  return { node, type: firstParam.type };
+  const viaModule = value instanceof Reference2 ? value.bestGuessOwningModule : null;
+  return { node, type: new Reference2(firstParam.type, viaModule) };
 }
 function assertEmittableInputType(type, contextFile, reflector, refEmitter) {
   (function walk(node) {
-    if (import_typescript48.default.isTypeReferenceNode(node) && import_typescript48.default.isIdentifier(node.typeName)) {
+    if (import_typescript49.default.isTypeReferenceNode(node) && import_typescript49.default.isIdentifier(node.typeName)) {
       const declaration = reflector.getDeclarationOfIdentifier(node.typeName);
       if (declaration !== null) {
         if (declaration.node.getSourceFile() !== contextFile) {
@@ -31347,16 +31419,16 @@ var DirectiveDecoratorHandler = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.mjs
-var import_typescript50 = __toESM(require("typescript"), 1);
+var import_typescript51 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/module_with_providers.mjs
-var import_typescript49 = __toESM(require("typescript"), 1);
+var import_typescript50 = __toESM(require("typescript"), 1);
 function createModuleWithProvidersResolver(reflector, isCore) {
   function _reflectModuleFromTypeParam(type, node) {
-    if (!import_typescript49.default.isTypeReferenceNode(type)) {
+    if (!import_typescript50.default.isTypeReferenceNode(type)) {
       return null;
     }
-    const typeName = type && (import_typescript49.default.isIdentifier(type.typeName) && type.typeName || import_typescript49.default.isQualifiedName(type.typeName) && type.typeName.right) || null;
+    const typeName = type && (import_typescript50.default.isIdentifier(type.typeName) && type.typeName || import_typescript50.default.isQualifiedName(type.typeName) && type.typeName.right) || null;
     if (typeName === null) {
       return null;
     }
@@ -31368,7 +31440,7 @@ function createModuleWithProvidersResolver(reflector, isCore) {
       return null;
     }
     if (type.typeArguments === void 0 || type.typeArguments.length !== 1) {
-      const parent = import_typescript49.default.isMethodDeclaration(node) && import_typescript49.default.isClassDeclaration(node.parent) ? node.parent : null;
+      const parent = import_typescript50.default.isMethodDeclaration(node) && import_typescript50.default.isClassDeclaration(node.parent) ? node.parent : null;
       const symbolName = (parent && parent.name ? parent.name.getText() + "." : "") + (node.name ? node.name.getText() : "anonymous");
       throw new FatalDiagnosticError(ErrorCode.NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC, type, `${symbolName} returns a ModuleWithProviders type without a generic type argument. Please add a generic type argument to the ModuleWithProviders type. If this occurrence is in library code you don't control, please contact the library authors.`);
     }
@@ -31376,13 +31448,13 @@ function createModuleWithProvidersResolver(reflector, isCore) {
     return typeNodeToValueExpr(arg);
   }
   function _reflectModuleFromLiteralType(type) {
-    if (!import_typescript49.default.isIntersectionTypeNode(type)) {
+    if (!import_typescript50.default.isIntersectionTypeNode(type)) {
       return null;
     }
     for (const t of type.types) {
-      if (import_typescript49.default.isTypeLiteralNode(t)) {
+      if (import_typescript50.default.isTypeLiteralNode(t)) {
         for (const m of t.members) {
-          const ngModuleType = import_typescript49.default.isPropertySignature(m) && import_typescript49.default.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
+          const ngModuleType = import_typescript50.default.isPropertySignature(m) && import_typescript50.default.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
           const ngModuleExpression = ngModuleType && typeNodeToValueExpr(ngModuleType);
           if (ngModuleExpression) {
             return ngModuleExpression;
@@ -31526,8 +31598,8 @@ var NgModuleDecoratorHandler = class {
     if (decorator.args === null || decorator.args.length > 1) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, `Incorrect number of arguments to @NgModule decorator`);
     }
-    const meta = decorator.args.length === 1 ? unwrapExpression(decorator.args[0]) : import_typescript50.default.factory.createObjectLiteralExpression([]);
-    if (!import_typescript50.default.isObjectLiteralExpression(meta)) {
+    const meta = decorator.args.length === 1 ? unwrapExpression(decorator.args[0]) : import_typescript51.default.factory.createObjectLiteralExpression([]);
+    if (!import_typescript51.default.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@NgModule argument must be an object literal");
     }
     const ngModule = reflectObjectLiteral(meta);
@@ -31587,7 +31659,7 @@ var NgModuleDecoratorHandler = class {
         id = new WrappedNodeExpr(idExpr);
       } else {
         const diag = makeDiagnostic(ErrorCode.WARN_NGMODULE_ID_UNNECESSARY, idExpr, `Using 'module.id' for NgModule.id is a common anti-pattern that is ignored by the Angular compiler.`);
-        diag.category = import_typescript50.default.DiagnosticCategory.Warning;
+        diag.category = import_typescript51.default.DiagnosticCategory.Warning;
         diagnostics.push(diag);
       }
     }
@@ -31639,16 +31711,16 @@ var NgModuleDecoratorHandler = class {
     }
     const rawProviders = ngModule.has("providers") ? ngModule.get("providers") : null;
     let wrappedProviders = null;
-    if (rawProviders !== null && (!import_typescript50.default.isArrayLiteralExpression(rawProviders) || rawProviders.elements.length > 0)) {
+    if (rawProviders !== null && (!import_typescript51.default.isArrayLiteralExpression(rawProviders) || rawProviders.elements.length > 0)) {
       wrappedProviders = new WrappedNodeExpr(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(rawProviders) : rawProviders);
     }
     const topLevelImports = [];
     if (this.compilationMode !== CompilationMode.LOCAL && ngModule.has("imports")) {
       const rawImports2 = unwrapExpression(ngModule.get("imports"));
       let topLevelExpressions = [];
-      if (import_typescript50.default.isArrayLiteralExpression(rawImports2)) {
+      if (import_typescript51.default.isArrayLiteralExpression(rawImports2)) {
         for (const element2 of rawImports2.elements) {
-          if (import_typescript50.default.isSpreadElement(element2)) {
+          if (import_typescript51.default.isSpreadElement(element2)) {
             topLevelExpressions.push(element2.expression);
             continue;
           }
@@ -31956,7 +32028,7 @@ function isNgModule(node, compilation) {
   return !compilation.dependencies.some((dep) => dep.ref.node === node);
 }
 function isModuleIdExpression(expr) {
-  return import_typescript50.default.isPropertyAccessExpression(expr) && import_typescript50.default.isIdentifier(expr.expression) && expr.expression.text === "module" && expr.name.text === "id";
+  return import_typescript51.default.isPropertyAccessExpression(expr) && import_typescript51.default.isIdentifier(expr.expression) && expr.expression.text === "module" && expr.name.text === "id";
 }
 function makeStandaloneBootstrapDiagnostic(ngModuleClass, bootstrappedClassRef, rawBootstrapExpr) {
   const componentClassName = bootstrappedClassRef.node.name.text;
@@ -31992,7 +32064,7 @@ function checkCustomElementSelectorForErrors(selector) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/resources.mjs
-var import_typescript52 = __toESM(require("typescript"), 1);
+var import_typescript53 = __toESM(require("typescript"), 1);
 function getTemplateDeclarationNodeForError(declaration) {
   return declaration.isInline ? declaration.expression : declaration.templateUrlExpression;
 }
@@ -32004,7 +32076,7 @@ function extractTemplate(node, template2, evaluator, depTracker, resourceLoader,
     let sourceMapping;
     let escapedString = false;
     let sourceMapUrl;
-    if (import_typescript52.default.isStringLiteral(template2.expression) || import_typescript52.default.isNoSubstitutionTemplateLiteral(template2.expression)) {
+    if (import_typescript53.default.isStringLiteral(template2.expression) || import_typescript53.default.isNoSubstitutionTemplateLiteral(template2.expression)) {
       sourceParseRange = getTemplateRange(template2.expression);
       sourceStr = template2.expression.getSourceFile().text;
       templateContent = template2.expression.text;
@@ -32176,7 +32248,7 @@ function preloadAndParseTemplate(evaluator, resourceLoader, depTracker, preanaly
 }
 function getTemplateRange(templateExpr) {
   const startPos = templateExpr.getStart() + 1;
-  const { line, character } = import_typescript52.default.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
+  const { line, character } = import_typescript53.default.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
   return {
     startPos,
     startLine: line,
@@ -32209,7 +32281,7 @@ function transformDecoratorResources(dec, component, styles, template2) {
   const metadata = new Map(component);
   if (metadata.has("templateUrl")) {
     metadata.delete("templateUrl");
-    metadata.set("template", import_typescript52.default.factory.createStringLiteral(template2.content));
+    metadata.set("template", import_typescript53.default.factory.createStringLiteral(template2.content));
   }
   if (metadata.has("styleUrls") || metadata.has("styles")) {
     metadata.delete("styles");
@@ -32217,20 +32289,20 @@ function transformDecoratorResources(dec, component, styles, template2) {
     if (styles.length > 0) {
       const styleNodes = styles.reduce((result, style) => {
         if (style.trim().length > 0) {
-          result.push(import_typescript52.default.factory.createStringLiteral(style));
+          result.push(import_typescript53.default.factory.createStringLiteral(style));
         }
         return result;
       }, []);
       if (styleNodes.length > 0) {
-        metadata.set("styles", import_typescript52.default.factory.createArrayLiteralExpression(styleNodes));
+        metadata.set("styles", import_typescript53.default.factory.createArrayLiteralExpression(styleNodes));
       }
     }
   }
   const newMetadataFields = [];
   for (const [name, value] of metadata.entries()) {
-    newMetadataFields.push(import_typescript52.default.factory.createPropertyAssignment(name, value));
+    newMetadataFields.push(import_typescript53.default.factory.createPropertyAssignment(name, value));
   }
-  return __spreadProps(__spreadValues({}, dec), { args: [import_typescript52.default.factory.createObjectLiteralExpression(newMetadataFields)] });
+  return __spreadProps(__spreadValues({}, dec), { args: [import_typescript53.default.factory.createObjectLiteralExpression(newMetadataFields)] });
 }
 function extractComponentStyleUrls(evaluator, component) {
   if (!component.has("styleUrls")) {
@@ -32240,9 +32312,9 @@ function extractComponentStyleUrls(evaluator, component) {
 }
 function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
   const styleUrls = [];
-  if (import_typescript52.default.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (import_typescript53.default.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const styleUrlExpr of styleUrlsExpr.elements) {
-      if (import_typescript52.default.isSpreadElement(styleUrlExpr)) {
+      if (import_typescript53.default.isSpreadElement(styleUrlExpr)) {
         styleUrls.push(...extractStyleUrlsFromExpression(evaluator, styleUrlExpr.expression));
       } else {
         const styleUrl = evaluator.evaluate(styleUrlExpr);
@@ -32274,10 +32346,10 @@ function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
 function extractStyleResources(resourceLoader, component, containingFile) {
   const styles = /* @__PURE__ */ new Set();
   function stringLiteralElements(array) {
-    return array.elements.filter((e) => import_typescript52.default.isStringLiteralLike(e));
+    return array.elements.filter((e) => import_typescript53.default.isStringLiteralLike(e));
   }
   const styleUrlsExpr = component.get("styleUrls");
-  if (styleUrlsExpr !== void 0 && import_typescript52.default.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (styleUrlsExpr !== void 0 && import_typescript53.default.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const expression of stringLiteralElements(styleUrlsExpr)) {
       try {
         const resourceUrl = resourceLoader.resolve(expression.text, containingFile);
@@ -32287,7 +32359,7 @@ function extractStyleResources(resourceLoader, component, containingFile) {
     }
   }
   const stylesExpr = component.get("styles");
-  if (stylesExpr !== void 0 && import_typescript52.default.isArrayLiteralExpression(stylesExpr)) {
+  if (stylesExpr !== void 0 && import_typescript53.default.isArrayLiteralExpression(stylesExpr)) {
     for (const expression of stringLiteralElements(stylesExpr)) {
       styles.add({ path: null, expression });
     }
@@ -32785,7 +32857,7 @@ var ComponentDecoratorHandler = class {
     });
   }
   typeCheck(ctx, node, meta) {
-    if (this.typeCheckScopeRegistry === null || !import_typescript53.default.isClassDeclaration(node)) {
+    if (this.typeCheckScopeRegistry === null || !import_typescript54.default.isClassDeclaration(node)) {
       return;
     }
     if (meta.isPoisoned && !this.usePoisonedData) {
@@ -33117,9 +33189,9 @@ var ComponentDecoratorHandler = class {
       }
       resolutionData.deferBlocks.set(deferBlock, deps);
     }
-    if (analysisData.meta.isStandalone && analysisData.rawImports !== null && import_typescript53.default.isArrayLiteralExpression(analysisData.rawImports)) {
+    if (analysisData.meta.isStandalone && analysisData.rawImports !== null && import_typescript54.default.isArrayLiteralExpression(analysisData.rawImports)) {
       for (const node of analysisData.rawImports.elements) {
-        if (!import_typescript53.default.isIdentifier(node)) {
+        if (!import_typescript54.default.isIdentifier(node)) {
           continue;
         }
         const imp = this.reflector.getImportOfIdentifier(node);
@@ -33183,7 +33255,7 @@ function validateStandaloneImports(importRefs, importExpr2, metaReader, scopeRea
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/injectable.mjs
-var import_typescript55 = __toESM(require("typescript"), 1);
+var import_typescript56 = __toESM(require("typescript"), 1);
 var InjectableDecoratorHandler = class {
   constructor(reflector, evaluator, isCore, strictCtorDeps, injectableRegistry, perf, includeClassMetadata, errorOnDuplicateProv = true) {
     this.reflector = reflector;
@@ -33296,7 +33368,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     };
   } else if (decorator.args.length === 1) {
     const metaNode = decorator.args[0];
-    if (!import_typescript55.default.isObjectLiteralExpression(metaNode)) {
+    if (!import_typescript56.default.isObjectLiteralExpression(metaNode)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, metaNode, `@Injectable argument must be an object literal`);
     }
     const meta = reflectObjectLiteral(metaNode);
@@ -33304,7 +33376,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     let deps = void 0;
     if ((meta.has("useClass") || meta.has("useFactory")) && meta.has("deps")) {
       const depsExpr = meta.get("deps");
-      if (!import_typescript55.default.isArrayLiteralExpression(depsExpr)) {
+      if (!import_typescript56.default.isArrayLiteralExpression(depsExpr)) {
         throw new FatalDiagnosticError(ErrorCode.VALUE_NOT_LITERAL, depsExpr, `@Injectable deps metadata must be an inline array`);
       }
       deps = depsExpr.elements.map((dep) => getDep(dep, reflector));
@@ -33389,12 +33461,12 @@ function getDep(dep, reflector) {
     }
     return true;
   }
-  if (import_typescript55.default.isArrayLiteralExpression(dep)) {
+  if (import_typescript56.default.isArrayLiteralExpression(dep)) {
     dep.elements.forEach((el) => {
       let isDecorator = false;
-      if (import_typescript55.default.isIdentifier(el)) {
+      if (import_typescript56.default.isIdentifier(el)) {
         isDecorator = maybeUpdateDecorator(el, reflector);
-      } else if (import_typescript55.default.isNewExpression(el) && import_typescript55.default.isIdentifier(el.expression)) {
+      } else if (import_typescript56.default.isNewExpression(el) && import_typescript56.default.isIdentifier(el.expression)) {
         const token = el.arguments && el.arguments.length > 0 && el.arguments[0] || void 0;
         isDecorator = maybeUpdateDecorator(el.expression, reflector, token);
       }
@@ -33407,7 +33479,7 @@ function getDep(dep, reflector) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/pipe.mjs
-var import_typescript56 = __toESM(require("typescript"), 1);
+var import_typescript57 = __toESM(require("typescript"), 1);
 var PipeSymbol = class extends SemanticSymbol {
   constructor(decl, name) {
     super(decl);
@@ -33463,7 +33535,7 @@ var PipeDecoratorHandler = class {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.node, "@Pipe must have exactly one argument");
     }
     const meta = unwrapExpression(decorator.args[0]);
-    if (!import_typescript56.default.isObjectLiteralExpression(meta)) {
+    if (!import_typescript57.default.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@Pipe must have a literal argument");
     }
     const pipe2 = reflectObjectLiteral(meta);
@@ -33628,7 +33700,7 @@ var Cycle = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/cycles/src/imports.mjs
-var import_typescript57 = __toESM(require("typescript"), 1);
+var import_typescript58 = __toESM(require("typescript"), 1);
 var ImportGraph = class {
   constructor(checker, perf) {
     this.checker = checker;
@@ -33672,10 +33744,10 @@ var ImportGraph = class {
     return this.perf.inPhase(PerfPhase.CycleDetection, () => {
       const imports = /* @__PURE__ */ new Set();
       for (const stmt of sf.statements) {
-        if (!import_typescript57.default.isImportDeclaration(stmt) && !import_typescript57.default.isExportDeclaration(stmt) || stmt.moduleSpecifier === void 0) {
+        if (!import_typescript58.default.isImportDeclaration(stmt) && !import_typescript58.default.isExportDeclaration(stmt) || stmt.moduleSpecifier === void 0) {
           continue;
         }
-        if (import_typescript57.default.isImportDeclaration(stmt) && stmt.importClause !== void 0 && isTypeOnlyImportClause(stmt.importClause)) {
+        if (import_typescript58.default.isImportDeclaration(stmt) && stmt.importClause !== void 0 && isTypeOnlyImportClause(stmt.importClause)) {
           continue;
         }
         const symbol = this.checker.getSymbolAtLocation(stmt.moduleSpecifier);
@@ -33683,7 +33755,7 @@ var ImportGraph = class {
           continue;
         }
         const moduleFile = symbol.valueDeclaration;
-        if (import_typescript57.default.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
+        if (import_typescript58.default.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
           imports.add(moduleFile);
         }
       }
@@ -33698,7 +33770,7 @@ function isTypeOnlyImportClause(node) {
   if (node.isTypeOnly) {
     return true;
   }
-  if (node.namedBindings !== void 0 && import_typescript57.default.isNamedImports(node.namedBindings) && node.namedBindings.elements.every((specifier) => specifier.isTypeOnly)) {
+  if (node.namedBindings !== void 0 && import_typescript58.default.isNamedImports(node.namedBindings) && node.namedBindings.elements.every((specifier) => specifier.isTypeOnly)) {
     return true;
   }
   return false;
@@ -33720,7 +33792,7 @@ var Found = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/entry_point/src/generator.mjs
-var import_typescript58 = __toESM(require("typescript"), 1);
+var import_typescript59 = __toESM(require("typescript"), 1);
 var FlatIndexGenerator = class {
   constructor(entryPoint, relativeFlatIndexPath, moduleName) {
     this.entryPoint = entryPoint;
@@ -33736,7 +33808,7 @@ var FlatIndexGenerator = class {
 
 export * from '${relativeEntryPoint}';
 `;
-    const genFile = import_typescript58.default.createSourceFile(this.flatIndexPath, contents, import_typescript58.default.ScriptTarget.ES2015, true, import_typescript58.default.ScriptKind.TS);
+    const genFile = import_typescript59.default.createSourceFile(this.flatIndexPath, contents, import_typescript59.default.ScriptTarget.ES2015, true, import_typescript59.default.ScriptKind.TS);
     if (this.moduleName !== null) {
       genFile.moduleName = this.moduleName;
     }
@@ -33761,7 +33833,7 @@ function findFlatIndexEntryPoint(rootFiles) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/entry_point/src/private_export_checker.mjs
-var import_typescript60 = __toESM(require("typescript"), 1);
+var import_typescript61 = __toESM(require("typescript"), 1);
 function checkForPrivateExports(entryPoint, checker, refGraph) {
   const diagnostics = [];
   const topLevelExports = /* @__PURE__ */ new Set();
@@ -33771,7 +33843,7 @@ function checkForPrivateExports(entryPoint, checker, refGraph) {
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   exportedSymbols.forEach((symbol) => {
-    if (symbol.flags & import_typescript60.default.SymbolFlags.Alias) {
+    if (symbol.flags & import_typescript61.default.SymbolFlags.Alias) {
       symbol = checker.getAliasedSymbol(symbol);
     }
     const decl = symbol.valueDeclaration;
@@ -33795,7 +33867,7 @@ function checkForPrivateExports(entryPoint, checker, refGraph) {
           visibleVia = transitivePath.map((seg) => getNameOfDeclaration(seg)).join(" -> ");
         }
         const diagnostic = __spreadProps(__spreadValues({
-          category: import_typescript60.default.DiagnosticCategory.Error,
+          category: import_typescript61.default.DiagnosticCategory.Error,
           code: ngErrorCode(ErrorCode.SYMBOL_NOT_EXPORTED),
           file: transitiveReference.getSourceFile()
         }, getPosOfDeclaration(transitiveReference)), {
@@ -33815,7 +33887,7 @@ function getPosOfDeclaration(decl) {
   };
 }
 function getIdentifierOfDeclaration(decl) {
-  if ((import_typescript60.default.isClassDeclaration(decl) || import_typescript60.default.isVariableDeclaration(decl) || import_typescript60.default.isFunctionDeclaration(decl)) && decl.name !== void 0 && import_typescript60.default.isIdentifier(decl.name)) {
+  if ((import_typescript61.default.isClassDeclaration(decl) || import_typescript61.default.isVariableDeclaration(decl) || import_typescript61.default.isFunctionDeclaration(decl)) && decl.name !== void 0 && import_typescript61.default.isIdentifier(decl.name)) {
     return decl.name;
   } else {
     return null;
@@ -33827,13 +33899,13 @@ function getNameOfDeclaration(decl) {
 }
 function getDescriptorOfDeclaration(decl) {
   switch (decl.kind) {
-    case import_typescript60.default.SyntaxKind.ClassDeclaration:
+    case import_typescript61.default.SyntaxKind.ClassDeclaration:
       return "class";
-    case import_typescript60.default.SyntaxKind.FunctionDeclaration:
+    case import_typescript61.default.SyntaxKind.FunctionDeclaration:
       return "function";
-    case import_typescript60.default.SyntaxKind.VariableDeclaration:
+    case import_typescript61.default.SyntaxKind.VariableDeclaration:
       return "variable";
-    case import_typescript60.default.SyntaxKind.EnumDeclaration:
+    case import_typescript61.default.SyntaxKind.EnumDeclaration:
       return "enum";
     default:
       return "declaration";
@@ -33903,10 +33975,10 @@ var UpdateMode;
 })(UpdateMode || (UpdateMode = {}));
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/program_driver/src/ts_create_program_driver.mjs
-var import_typescript64 = __toESM(require("typescript"), 1);
+var import_typescript65 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/adapter.mjs
-var import_typescript61 = __toESM(require("typescript"), 1);
+var import_typescript62 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/expando.mjs
 var NgExtension = Symbol("NgExtension");
@@ -34037,10 +34109,10 @@ var ShimAdapter = class {
       }
       const prefix = match[1];
       let baseFileName = absoluteFrom(prefix + ".ts");
-      let inputFile = this.delegate.getSourceFile(baseFileName, import_typescript61.default.ScriptTarget.Latest);
+      let inputFile = this.delegate.getSourceFile(baseFileName, import_typescript62.default.ScriptTarget.Latest);
       if (inputFile === void 0) {
         baseFileName = absoluteFrom(prefix + ".tsx");
-        inputFile = this.delegate.getSourceFile(baseFileName, import_typescript61.default.ScriptTarget.Latest);
+        inputFile = this.delegate.getSourceFile(baseFileName, import_typescript62.default.ScriptTarget.Latest);
       }
       if (inputFile === void 0 || isShim(inputFile)) {
         return void 0;
@@ -34195,7 +34267,7 @@ var TsCreateProgramDriver = class {
       this.sfMap.clear();
     }
     for (const [filePath, { newText, originalFile }] of contents.entries()) {
-      const sf = import_typescript64.default.createSourceFile(filePath, newText, import_typescript64.default.ScriptTarget.Latest, true);
+      const sf = import_typescript65.default.createSourceFile(filePath, newText, import_typescript65.default.ScriptTarget.Latest, true);
       if (originalFile !== null) {
         sf[NgOriginalFile] = originalFile;
       }
@@ -34204,7 +34276,7 @@ var TsCreateProgramDriver = class {
     const host = new UpdatedProgramHost(this.sfMap, this.originalProgram, this.originalHost, this.shimExtensionPrefixes);
     const oldProgram = this.program;
     retagAllTsFiles(oldProgram);
-    this.program = import_typescript64.default.createProgram({
+    this.program = import_typescript65.default.createProgram({
       host,
       rootNames: this.program.getRootFileNames(),
       options: this.options,
@@ -34919,7 +34991,7 @@ var NgModuleIndexImpl = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/resource/src/loader.mjs
-var import_typescript67 = __toESM(require("typescript"), 1);
+var import_typescript68 = __toESM(require("typescript"), 1);
 var CSS_PREPROCESSOR_EXT = /(\.scss|\.sass|\.less|\.styl)$/;
 var RESOURCE_MARKER = ".$ngresource$";
 var RESOURCE_MARKER_TS = RESOURCE_MARKER + ".ts";
@@ -35031,7 +35103,7 @@ var AdapterResourceLoader = class {
     return this.adapter.rootDirs.map((rootDir) => join(rootDir, segment));
   }
   getResolvedCandidateLocations(url, fromFile) {
-    const failedLookup = import_typescript67.default.resolveModuleName(url + RESOURCE_MARKER, fromFile, this.options, this.lookupResolutionHost);
+    const failedLookup = import_typescript68.default.resolveModuleName(url + RESOURCE_MARKER, fromFile, this.options, this.lookupResolutionHost);
     if (failedLookup.failedLookupLocations === void 0) {
       throw new Error(`Internal error: expected to find failedLookupLocations during resolution of resource '${url}' in context of ${fromFile}`);
     }
@@ -35187,7 +35259,7 @@ var SymbolKind;
 })(SymbolKind || (SymbolKind = {}));
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/diagnostic.mjs
-var import_typescript68 = __toESM(require("typescript"), 1);
+var import_typescript69 = __toESM(require("typescript"), 1);
 function makeTemplateDiagnostic(templateId, mapping, span, category, code, messageText, relatedMessages) {
   var _a2;
   if (mapping.type === "direct") {
@@ -35196,7 +35268,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
       relatedInformation = [];
       for (const relatedMessage of relatedMessages) {
         relatedInformation.push({
-          category: import_typescript68.default.DiagnosticCategory.Message,
+          category: import_typescript69.default.DiagnosticCategory.Message,
           code: 0,
           file: relatedMessage.sourceFile,
           start: relatedMessage.start,
@@ -35225,7 +35297,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
     if (relatedMessages !== void 0) {
       for (const relatedMessage of relatedMessages) {
         relatedInformation.push({
-          category: import_typescript68.default.DiagnosticCategory.Message,
+          category: import_typescript69.default.DiagnosticCategory.Message,
           code: 0,
           file: relatedMessage.sourceFile,
           start: relatedMessage.start,
@@ -35255,7 +35327,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
       };
     }
     relatedInformation.push({
-      category: import_typescript68.default.DiagnosticCategory.Message,
+      category: import_typescript69.default.DiagnosticCategory.Message,
       code: 0,
       file: componentSf,
       start: mapping.node.getStart(),
@@ -35290,7 +35362,7 @@ function parseTemplateAsSourceFile(fileName, template2) {
   if (parseTemplateAsSourceFileForTest !== null) {
     return parseTemplateAsSourceFileForTest(fileName, template2);
   }
-  return import_typescript68.default.createSourceFile(fileName, template2, import_typescript68.default.ScriptTarget.Latest, false, import_typescript68.default.ScriptKind.JSX);
+  return import_typescript69.default.createSourceFile(fileName, template2, import_typescript69.default.ScriptTarget.Latest, false, import_typescript69.default.ScriptKind.JSX);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/id.mjs
@@ -35311,14 +35383,14 @@ function allocateTemplateId(sf) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/completion.mjs
-var import_typescript70 = __toESM(require("typescript"), 1);
+var import_typescript71 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/comments.mjs
-var import_typescript69 = __toESM(require("typescript"), 1);
+var import_typescript70 = __toESM(require("typescript"), 1);
 var parseSpanComment = /^(\d+),(\d+)$/;
 function readSpanComment(node, sourceFile = node.getSourceFile()) {
-  return import_typescript69.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== import_typescript69.default.SyntaxKind.MultiLineCommentTrivia) {
+  return import_typescript70.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== import_typescript70.default.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -35341,25 +35413,25 @@ var ExpressionIdentifier;
   ExpressionIdentifier2["EVENT_PARAMETER"] = "EP";
 })(ExpressionIdentifier || (ExpressionIdentifier = {}));
 function addExpressionIdentifier(node, identifier) {
-  import_typescript69.default.addSyntheticTrailingComment(
+  import_typescript70.default.addSyntheticTrailingComment(
     node,
-    import_typescript69.default.SyntaxKind.MultiLineCommentTrivia,
+    import_typescript70.default.SyntaxKind.MultiLineCommentTrivia,
     `${CommentTriviaType.EXPRESSION_TYPE_IDENTIFIER}:${identifier}`,
     false
   );
 }
 var IGNORE_FOR_DIAGNOSTICS_MARKER = `${CommentTriviaType.DIAGNOSTIC}:ignore`;
 function markIgnoreDiagnostics(node) {
-  import_typescript69.default.addSyntheticTrailingComment(
+  import_typescript70.default.addSyntheticTrailingComment(
     node,
-    import_typescript69.default.SyntaxKind.MultiLineCommentTrivia,
+    import_typescript70.default.SyntaxKind.MultiLineCommentTrivia,
     IGNORE_FOR_DIAGNOSTICS_MARKER,
     false
   );
 }
 function hasIgnoreForDiagnosticsMarker(node, sourceFile) {
-  return import_typescript69.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== import_typescript69.default.SyntaxKind.MultiLineCommentTrivia) {
+  return import_typescript70.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== import_typescript70.default.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -35433,8 +35505,8 @@ function findAllMatchingNodes(tcb, opts) {
   return results;
 }
 function hasExpressionIdentifier(sourceFile, node, identifier) {
-  return import_typescript69.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== import_typescript69.default.SyntaxKind.MultiLineCommentTrivia) {
+  return import_typescript70.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== import_typescript70.default.SyntaxKind.MultiLineCommentTrivia) {
       return false;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -35452,7 +35524,7 @@ var CompletionEngine = class {
     this.templateContextCache = /* @__PURE__ */ new Map();
     this.expressionCompletionCache = /* @__PURE__ */ new Map();
     const globalRead = findFirstMatchingNode(this.tcb, {
-      filter: import_typescript70.default.isPropertyAccessExpression,
+      filter: import_typescript71.default.isPropertyAccessExpression,
       withExpressionIdentifier: ExpressionIdentifier.COMPONENT_COMPLETION
     });
     if (globalRead !== null) {
@@ -35476,7 +35548,7 @@ var CompletionEngine = class {
     let nodeContext = null;
     if (node instanceof EmptyExpr) {
       const nodeLocation = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript70.default.isIdentifier,
+        filter: import_typescript71.default.isIdentifier,
         withSpan: node.sourceSpan
       });
       if (nodeLocation !== null) {
@@ -35489,7 +35561,7 @@ var CompletionEngine = class {
     }
     if (node instanceof PropertyRead && node.receiver instanceof ImplicitReceiver) {
       const nodeLocation = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript70.default.isPropertyAccessExpression,
+        filter: import_typescript71.default.isPropertyAccessExpression,
         withSpan: node.sourceSpan
       });
       if (nodeLocation) {
@@ -35513,21 +35585,21 @@ var CompletionEngine = class {
     let tsExpr = null;
     if (expr instanceof PropertyRead || expr instanceof PropertyWrite) {
       tsExpr = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript70.default.isPropertyAccessExpression,
+        filter: import_typescript71.default.isPropertyAccessExpression,
         withSpan: expr.nameSpan
       });
     } else if (expr instanceof SafePropertyRead) {
       const ternaryExpr = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript70.default.isParenthesizedExpression,
+        filter: import_typescript71.default.isParenthesizedExpression,
         withSpan: expr.sourceSpan
       });
-      if (ternaryExpr === null || !import_typescript70.default.isConditionalExpression(ternaryExpr.expression)) {
+      if (ternaryExpr === null || !import_typescript71.default.isConditionalExpression(ternaryExpr.expression)) {
         return null;
       }
       const whenTrue = ternaryExpr.expression.whenTrue;
-      if (import_typescript70.default.isPropertyAccessExpression(whenTrue)) {
+      if (import_typescript71.default.isPropertyAccessExpression(whenTrue)) {
         tsExpr = whenTrue;
-      } else if (import_typescript70.default.isCallExpression(whenTrue) && import_typescript70.default.isPropertyAccessExpression(whenTrue.expression)) {
+      } else if (import_typescript71.default.isCallExpression(whenTrue) && import_typescript71.default.isPropertyAccessExpression(whenTrue.expression)) {
         tsExpr = whenTrue.expression;
       }
     }
@@ -35549,15 +35621,15 @@ var CompletionEngine = class {
     let tsExpr = null;
     if (expr instanceof TextAttribute) {
       const strNode = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript70.default.isParenthesizedExpression,
+        filter: import_typescript71.default.isParenthesizedExpression,
         withSpan: expr.sourceSpan
       });
-      if (strNode !== null && import_typescript70.default.isStringLiteral(strNode.expression)) {
+      if (strNode !== null && import_typescript71.default.isStringLiteral(strNode.expression)) {
         tsExpr = strNode.expression;
       }
     } else {
       tsExpr = findFirstMatchingNode(this.tcb, {
-        filter: (n) => import_typescript70.default.isStringLiteral(n) || import_typescript70.default.isNumericLiteral(n),
+        filter: (n) => import_typescript71.default.isStringLiteral(n) || import_typescript71.default.isNumericLiteral(n),
         withSpan: expr.sourceSpan
       });
     }
@@ -35565,7 +35637,7 @@ var CompletionEngine = class {
       return null;
     }
     let positionInShimFile = tsExpr.getEnd();
-    if (import_typescript70.default.isStringLiteral(tsExpr)) {
+    if (import_typescript71.default.isStringLiteral(tsExpr)) {
       positionInShimFile -= 1;
     }
     const res = {
@@ -35603,7 +35675,7 @@ var CompletionEngine = class {
 var import_typescript85 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/dom.mjs
-var import_typescript71 = __toESM(require("typescript"), 1);
+var import_typescript72 = __toESM(require("typescript"), 1);
 var REGISTRY = new DomElementSchemaRegistry();
 var REMOVE_XHTML_REGEX = /^:xhtml:/;
 var RegistryDomSchemaChecker = class {
@@ -35628,7 +35700,7 @@ var RegistryDomSchemaChecker = class {
       } else {
         errorMsg += `2. To allow any element add 'NO_ERRORS_SCHEMA' to the ${schemas2} of this component.`;
       }
-      const diag = makeTemplateDiagnostic(id, mapping, element2.startSourceSpan, import_typescript71.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ELEMENT), errorMsg);
+      const diag = makeTemplateDiagnostic(id, mapping, element2.startSourceSpan, import_typescript72.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ELEMENT), errorMsg);
       this._diagnostics.push(diag);
     }
   }
@@ -35648,7 +35720,7 @@ var RegistryDomSchemaChecker = class {
 2. If '${element2.name}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the ${schemas2} of this component to suppress this message.
 3. To allow any property add 'NO_ERRORS_SCHEMA' to the ${schemas2} of this component.`;
       }
-      const diag = makeTemplateDiagnostic(id, mapping, span, import_typescript71.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ATTRIBUTE), errorMsg);
+      const diag = makeTemplateDiagnostic(id, mapping, span, import_typescript72.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ATTRIBUTE), errorMsg);
       this._diagnostics.push(diag);
     }
   }
@@ -35658,77 +35730,77 @@ var RegistryDomSchemaChecker = class {
 var import_typescript78 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/ts_util.mjs
-var import_typescript72 = __toESM(require("typescript"), 1);
+var import_typescript73 = __toESM(require("typescript"), 1);
 var SAFE_TO_CAST_WITHOUT_PARENS = /* @__PURE__ */ new Set([
-  import_typescript72.default.SyntaxKind.ParenthesizedExpression,
-  import_typescript72.default.SyntaxKind.Identifier,
-  import_typescript72.default.SyntaxKind.CallExpression,
-  import_typescript72.default.SyntaxKind.NonNullExpression,
-  import_typescript72.default.SyntaxKind.ElementAccessExpression,
-  import_typescript72.default.SyntaxKind.PropertyAccessExpression,
-  import_typescript72.default.SyntaxKind.ArrayLiteralExpression,
-  import_typescript72.default.SyntaxKind.ObjectLiteralExpression,
-  import_typescript72.default.SyntaxKind.StringLiteral,
-  import_typescript72.default.SyntaxKind.NumericLiteral,
-  import_typescript72.default.SyntaxKind.TrueKeyword,
-  import_typescript72.default.SyntaxKind.FalseKeyword,
-  import_typescript72.default.SyntaxKind.NullKeyword,
-  import_typescript72.default.SyntaxKind.UndefinedKeyword
+  import_typescript73.default.SyntaxKind.ParenthesizedExpression,
+  import_typescript73.default.SyntaxKind.Identifier,
+  import_typescript73.default.SyntaxKind.CallExpression,
+  import_typescript73.default.SyntaxKind.NonNullExpression,
+  import_typescript73.default.SyntaxKind.ElementAccessExpression,
+  import_typescript73.default.SyntaxKind.PropertyAccessExpression,
+  import_typescript73.default.SyntaxKind.ArrayLiteralExpression,
+  import_typescript73.default.SyntaxKind.ObjectLiteralExpression,
+  import_typescript73.default.SyntaxKind.StringLiteral,
+  import_typescript73.default.SyntaxKind.NumericLiteral,
+  import_typescript73.default.SyntaxKind.TrueKeyword,
+  import_typescript73.default.SyntaxKind.FalseKeyword,
+  import_typescript73.default.SyntaxKind.NullKeyword,
+  import_typescript73.default.SyntaxKind.UndefinedKeyword
 ]);
 function tsCastToAny(expr) {
   if (!SAFE_TO_CAST_WITHOUT_PARENS.has(expr.kind)) {
-    expr = import_typescript72.default.factory.createParenthesizedExpression(expr);
+    expr = import_typescript73.default.factory.createParenthesizedExpression(expr);
   }
-  return import_typescript72.default.factory.createParenthesizedExpression(import_typescript72.default.factory.createAsExpression(expr, import_typescript72.default.factory.createKeywordTypeNode(import_typescript72.default.SyntaxKind.AnyKeyword)));
+  return import_typescript73.default.factory.createParenthesizedExpression(import_typescript73.default.factory.createAsExpression(expr, import_typescript73.default.factory.createKeywordTypeNode(import_typescript73.default.SyntaxKind.AnyKeyword)));
 }
 function tsCreateElement(tagName) {
-  const createElement = import_typescript72.default.factory.createPropertyAccessExpression(
-    import_typescript72.default.factory.createIdentifier("document"),
+  const createElement = import_typescript73.default.factory.createPropertyAccessExpression(
+    import_typescript73.default.factory.createIdentifier("document"),
     "createElement"
   );
-  return import_typescript72.default.factory.createCallExpression(
+  return import_typescript73.default.factory.createCallExpression(
     createElement,
     void 0,
-    [import_typescript72.default.factory.createStringLiteral(tagName)]
+    [import_typescript73.default.factory.createStringLiteral(tagName)]
   );
 }
 function tsDeclareVariable(id, type) {
-  const decl = import_typescript72.default.factory.createVariableDeclaration(
+  const decl = import_typescript73.default.factory.createVariableDeclaration(
     id,
     void 0,
     type,
-    import_typescript72.default.factory.createNonNullExpression(import_typescript72.default.factory.createNull())
+    import_typescript73.default.factory.createNonNullExpression(import_typescript73.default.factory.createNull())
   );
-  return import_typescript72.default.factory.createVariableStatement(
+  return import_typescript73.default.factory.createVariableStatement(
     void 0,
     [decl]
   );
 }
 function tsCreateTypeQueryForCoercedInput(typeName, coercedInputName) {
-  return import_typescript72.default.factory.createTypeQueryNode(import_typescript72.default.factory.createQualifiedName(typeName, `ngAcceptInputType_${coercedInputName}`));
+  return import_typescript73.default.factory.createTypeQueryNode(import_typescript73.default.factory.createQualifiedName(typeName, `ngAcceptInputType_${coercedInputName}`));
 }
 function tsCreateVariable(id, initializer) {
-  const decl = import_typescript72.default.factory.createVariableDeclaration(
+  const decl = import_typescript73.default.factory.createVariableDeclaration(
     id,
     void 0,
     void 0,
     initializer
   );
-  return import_typescript72.default.factory.createVariableStatement(
+  return import_typescript73.default.factory.createVariableStatement(
     void 0,
     [decl]
   );
 }
 function tsCallMethod(receiver, methodName, args = []) {
-  const methodAccess = import_typescript72.default.factory.createPropertyAccessExpression(receiver, methodName);
-  return import_typescript72.default.factory.createCallExpression(
+  const methodAccess = import_typescript73.default.factory.createPropertyAccessExpression(receiver, methodName);
+  return import_typescript73.default.factory.createCallExpression(
     methodAccess,
     void 0,
     args
   );
 }
 function isAccessExpression2(node) {
-  return import_typescript72.default.isPropertyAccessExpression(node) || import_typescript72.default.isElementAccessExpression(node);
+  return import_typescript73.default.isPropertyAccessExpression(node) || import_typescript73.default.isElementAccessExpression(node);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.mjs
@@ -35739,83 +35811,6 @@ var import_typescript75 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.mjs
 var import_typescript74 = __toESM(require("typescript"), 1);
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_emitter.mjs
-var import_typescript73 = __toESM(require("typescript"), 1);
-var INELIGIBLE = {};
-function canEmitType(type, canEmit) {
-  return canEmitTypeWorker(type);
-  function canEmitTypeWorker(type2) {
-    return visitNode(type2) !== INELIGIBLE;
-  }
-  function visitNode(node) {
-    if (import_typescript73.default.isImportTypeNode(node)) {
-      return INELIGIBLE;
-    }
-    if (import_typescript73.default.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
-      return INELIGIBLE;
-    } else {
-      return import_typescript73.default.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 (import_typescript73.default.isImportTypeNode(node)) {
-          throw new Error("Unable to emit import type");
-        }
-        if (import_typescript73.default.isTypeReferenceNode(node)) {
-          return this.emitTypeReference(node);
-        } else if (import_typescript73.default.isLiteralExpression(node)) {
-          let clone;
-          if (import_typescript73.default.isStringLiteral(node)) {
-            clone = import_typescript73.default.factory.createStringLiteral(node.text);
-          } else if (import_typescript73.default.isNumericLiteral(node)) {
-            clone = import_typescript73.default.factory.createNumericLiteral(node.text);
-          } else if (import_typescript73.default.isBigIntLiteral(node)) {
-            clone = import_typescript73.default.factory.createBigIntLiteral(node.text);
-          } else if (import_typescript73.default.isNoSubstitutionTemplateLiteral(node)) {
-            clone = import_typescript73.default.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
-          } else if (import_typescript73.default.isRegularExpressionLiteral(node)) {
-            clone = import_typescript73.default.factory.createRegularExpressionLiteral(node.text);
-          } else {
-            throw new Error(`Unsupported literal kind ${import_typescript73.default.SyntaxKind[node.kind]}`);
-          }
-          import_typescript73.default.setTextRange(clone, { pos: -1, end: -1 });
-          return clone;
-        } else {
-          return import_typescript73.default.visitEachChild(node, visitNode, context);
-        }
-      };
-      return (node) => import_typescript73.default.visitNode(node, visitNode, import_typescript73.default.isTypeNode);
-    };
-    return import_typescript73.default.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 = import_typescript73.default.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
-    }
-    return import_typescript73.default.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
-  }
-};
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.mjs
 var TypeParameterEmitter = class {
   constructor(typeParameters, reflector) {
     this.typeParameters = typeParameters;
@@ -36040,7 +36035,7 @@ function constructTypeCtorParameter(node, meta, rawType) {
         void 0,
         classPropertyName,
         void 0,
-        transform == null ? tsCreateTypeQueryForCoercedInput(rawType.typeName, classPropertyName) : transform.type
+        transform == null ? tsCreateTypeQueryForCoercedInput(rawType.typeName, classPropertyName) : transform.type.node
       ));
     }
   }
@@ -37089,7 +37084,7 @@ var TcbDirectiveInputsOp = class extends TcbOp {
         }
         if (this.dir.coercedInputFields.has(fieldName)) {
           let type;
-          if (transformType) {
+          if (transformType !== null) {
             type = this.tcb.env.referenceTransplantedType(new TransplantedType(transformType));
           } else {
             const dirTypeRef = this.tcb.env.referenceType(this.dir.ref);