@angular/core 16.0.0-next.0 → 16.0.0-next.2

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

@@ -16111,7 +16111,7 @@ function publishFacade(global2) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("16.0.0-next.0");
+var VERSION2 = new Version("16.0.0-next.2");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -17426,7 +17426,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.0.0-next.0"));
+  definitionMap.set("version", literal("16.0.0-next.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -17495,7 +17495,7 @@ function createDirectiveDefinitionMap(meta) {
   var _a;
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION2));
-  definitionMap.set("version", literal("16.0.0-next.0"));
+  definitionMap.set("version", literal("16.0.0-next.2"));
   definitionMap.set("type", meta.internalType);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -17677,7 +17677,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.0.0-next.0"));
+  definitionMap.set("version", literal("16.0.0-next.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.internalType);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -17700,7 +17700,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("16.0.0-next.0"));
+  definitionMap.set("version", literal("16.0.0-next.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.internalType);
   if (meta.providedIn !== void 0) {
@@ -17738,7 +17738,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("16.0.0-next.0"));
+  definitionMap.set("version", literal("16.0.0-next.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.internalType);
   definitionMap.set("providers", meta.providers);
@@ -17759,7 +17759,7 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION6));
-  definitionMap.set("version", literal("16.0.0-next.0"));
+  definitionMap.set("version", literal("16.0.0-next.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.internalType);
   if (meta.bootstrap.length > 0) {
@@ -17794,7 +17794,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("16.0.0-next.0"));
+  definitionMap.set("version", literal("16.0.0-next.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.internalType);
   if (meta.isStandalone) {
@@ -17811,7 +17811,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("16.0.0-next.0");
+var VERSION3 = new Version("16.0.0-next.2");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;
@@ -17829,7 +17829,7 @@ var EmitFlags;
 var import_typescript2 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/program.mjs
-var import_typescript95 = __toESM(require("typescript"), 1);
+var import_typescript94 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/i18n.mjs
 var path = __toESM(require("path"), 1);
@@ -17920,8 +17920,8 @@ function compareVersions(v1, v2) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/typescript_support.mjs
-var MIN_TS_VERSION = "4.8.2";
-var MAX_TS_VERSION = "5.0.0";
+var MIN_TS_VERSION = "4.9.3";
+var MAX_TS_VERSION = "5.1.0";
 var tsVersion = import_typescript3.default.version;
 function checkVersion(version, minVersion, maxVersion) {
   if (compareVersions(version, minVersion) < 0 || compareVersions(version, maxVersion) >= 0) {
@@ -17933,7 +17933,7 @@ function verifySupportedTypeScriptVersion() {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/src/compiler.mjs
-var import_typescript91 = __toESM(require("typescript"), 1);
+var import_typescript90 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/di.mjs
 var import_typescript19 = __toESM(require("typescript"), 1);
@@ -19615,7 +19615,7 @@ function getOriginNodeForDiagnostics(expr, container) {
   }
 }
 function isAbstractClassDeclaration(clazz) {
-  return clazz.modifiers !== void 0 && clazz.modifiers.some((mod) => mod.kind === import_typescript18.default.SyntaxKind.AbstractKeyword);
+  return import_typescript18.default.canHaveModifiers(clazz) && clazz.modifiers !== void 0 ? clazz.modifiers.some((mod) => mod.kind === import_typescript18.default.SyntaxKind.AbstractKeyword) : false;
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/common/src/di.mjs
@@ -21799,7 +21799,7 @@ function extractSchemas(rawExpr, evaluator, context) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
-var import_typescript52 = __toESM(require("typescript"), 1);
+var import_typescript51 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.mjs
 var import_typescript31 = __toESM(require("typescript"), 1);
@@ -23303,7 +23303,7 @@ function containsErrors(diagnostics) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
-var import_typescript44 = __toESM(require("typescript"), 1);
+var import_typescript43 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/context.mjs
 var Context = class {
@@ -23586,39 +23586,7 @@ function createRange(span) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
-var import_typescript41 = __toESM(require("typescript"), 1);
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/ts_compatibility/src/ts_cross_version_utils.mjs
 var import_typescript40 = __toESM(require("typescript"), 1);
-var IS_AFTER_TS_49 = isAfterVersion(4, 9);
-var createParameterDeclaration = IS_AFTER_TS_49 ? import_typescript40.default.factory.createParameterDeclaration : (modifiers, dotDotDotToken, name, questionToken, type, initializer) => import_typescript40.default.factory.createParameterDeclaration(...splitModifiers(modifiers), dotDotDotToken, name, questionToken, type, initializer);
-var createImportDeclaration = IS_AFTER_TS_49 ? import_typescript40.default.factory.createImportDeclaration : (modifiers, importClause, moduleSpecifier, assertClause) => import_typescript40.default.factory.createImportDeclaration(void 0, modifiers, importClause, moduleSpecifier, assertClause);
-var createFunctionDeclaration = IS_AFTER_TS_49 ? import_typescript40.default.factory.createFunctionDeclaration : (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => import_typescript40.default.factory.createFunctionDeclaration(...splitModifiers(modifiers), asteriskToken, name, typeParameters, parameters, type, body);
-var createIndexSignature = IS_AFTER_TS_49 ? import_typescript40.default.factory.createIndexSignature : (modifiers, parameters, type) => import_typescript40.default.factory.createIndexSignature(modifiers, parameters, type);
-function splitModifiers(allModifiers) {
-  if (!allModifiers) {
-    return [void 0, void 0];
-  }
-  const decorators = [];
-  const modifiers = [];
-  for (const current of allModifiers) {
-    if (import_typescript40.default.isDecorator(current)) {
-      decorators.push(current);
-    } else {
-      modifiers.push(current);
-    }
-  }
-  return [decorators.length ? decorators : void 0, modifiers.length ? modifiers : void 0];
-}
-function isAfterVersion(targetMajor, targetMinor) {
-  const [major, minor] = import_typescript40.default.versionMajorMinor.split(".").map((part) => parseInt(part));
-  if (major < targetMajor) {
-    return false;
-  }
-  return major === targetMajor ? minor >= targetMinor : true;
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/type_translator.mjs
 function translateType(type, imports) {
   return type.visitType(new TypeTranslatorVisitor(imports), new Context(false));
 }
@@ -23629,16 +23597,16 @@ var TypeTranslatorVisitor = class {
   visitBuiltinType(type, context) {
     switch (type.name) {
       case BuiltinTypeName.Bool:
-        return import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.BooleanKeyword);
+        return import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.BooleanKeyword);
       case BuiltinTypeName.Dynamic:
-        return import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.AnyKeyword);
+        return import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.AnyKeyword);
       case BuiltinTypeName.Int:
       case BuiltinTypeName.Number:
-        return import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.NumberKeyword);
+        return import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.NumberKeyword);
       case BuiltinTypeName.String:
-        return import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.StringKeyword);
+        return import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.StringKeyword);
       case BuiltinTypeName.None:
-        return import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.NeverKeyword);
+        return import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.NeverKeyword);
       default:
         throw new Error(`Unsupported builtin type: ${BuiltinTypeName[type.name]}`);
     }
@@ -23648,28 +23616,28 @@ var TypeTranslatorVisitor = class {
     if (type.typeParams === null) {
       return typeNode;
     }
-    if (!import_typescript41.default.isTypeReferenceNode(typeNode)) {
+    if (!import_typescript40.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_typescript41.default.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
+    return import_typescript40.default.factory.createTypeReferenceNode(typeNode.typeName, typeArgs);
   }
   visitArrayType(type, context) {
-    return import_typescript41.default.factory.createArrayTypeNode(this.translateType(type.of, context));
+    return import_typescript40.default.factory.createArrayTypeNode(this.translateType(type.of, context));
   }
   visitMapType(type, context) {
-    const parameter = createParameterDeclaration(void 0, void 0, "key", void 0, import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.StringKeyword));
-    const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.UnknownKeyword);
-    const indexSignature = createIndexSignature(void 0, [parameter], typeArgs);
-    return import_typescript41.default.factory.createTypeLiteralNode([indexSignature]);
+    const parameter = import_typescript40.default.factory.createParameterDeclaration(void 0, void 0, "key", void 0, import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.StringKeyword));
+    const typeArgs = type.valueType !== null ? this.translateType(type.valueType, context) : import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.UnknownKeyword);
+    const indexSignature = import_typescript40.default.factory.createIndexSignature(void 0, [parameter], typeArgs);
+    return import_typescript40.default.factory.createTypeLiteralNode([indexSignature]);
   }
   visitReadVarExpr(ast, context) {
     if (ast.name === null) {
       throw new Error(`ReadVarExpr with no variable name in type`);
     }
-    return import_typescript41.default.factory.createTypeQueryNode(import_typescript41.default.factory.createIdentifier(ast.name));
+    return import_typescript40.default.factory.createTypeQueryNode(import_typescript40.default.factory.createIdentifier(ast.name));
   }
   visitWriteVarExpr(expr, context) {
     throw new Error("Method not implemented.");
@@ -23691,15 +23659,15 @@ var TypeTranslatorVisitor = class {
   }
   visitLiteralExpr(ast, context) {
     if (ast.value === null) {
-      return import_typescript41.default.factory.createLiteralTypeNode(import_typescript41.default.factory.createNull());
+      return import_typescript40.default.factory.createLiteralTypeNode(import_typescript40.default.factory.createNull());
     } else if (ast.value === void 0) {
-      return import_typescript41.default.factory.createKeywordTypeNode(import_typescript41.default.SyntaxKind.UndefinedKeyword);
+      return import_typescript40.default.factory.createKeywordTypeNode(import_typescript40.default.SyntaxKind.UndefinedKeyword);
     } else if (typeof ast.value === "boolean") {
-      return import_typescript41.default.factory.createLiteralTypeNode(ast.value ? import_typescript41.default.factory.createTrue() : import_typescript41.default.factory.createFalse());
+      return import_typescript40.default.factory.createLiteralTypeNode(ast.value ? import_typescript40.default.factory.createTrue() : import_typescript40.default.factory.createFalse());
     } else if (typeof ast.value === "number") {
-      return import_typescript41.default.factory.createLiteralTypeNode(import_typescript41.default.factory.createNumericLiteral(ast.value));
+      return import_typescript40.default.factory.createLiteralTypeNode(import_typescript40.default.factory.createNumericLiteral(ast.value));
     } else {
-      return import_typescript41.default.factory.createLiteralTypeNode(import_typescript41.default.factory.createStringLiteral(ast.value));
+      return import_typescript40.default.factory.createLiteralTypeNode(import_typescript40.default.factory.createStringLiteral(ast.value));
     }
   }
   visitLocalizedString(ast, context) {
@@ -23710,10 +23678,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_typescript41.default.factory.createIdentifier(symbol);
-    const typeName = moduleImport ? import_typescript41.default.factory.createQualifiedName(moduleImport, symbolIdentifier) : symbolIdentifier;
+    const symbolIdentifier = import_typescript40.default.factory.createIdentifier(symbol);
+    const typeName = moduleImport ? import_typescript40.default.factory.createQualifiedName(moduleImport, symbolIdentifier) : symbolIdentifier;
     const typeArguments = ast.typeParams !== null ? ast.typeParams.map((type) => this.translateType(type, context)) : void 0;
-    return import_typescript41.default.factory.createTypeReferenceNode(typeName, typeArguments);
+    return import_typescript40.default.factory.createTypeReferenceNode(typeName, typeArguments);
   }
   visitConditionalExpr(ast, context) {
     throw new Error("Method not implemented.");
@@ -23738,125 +23706,125 @@ var TypeTranslatorVisitor = class {
   }
   visitLiteralArrayExpr(ast, context) {
     const values = ast.entries.map((expr) => this.translateExpression(expr, context));
-    return import_typescript41.default.factory.createTupleTypeNode(values);
+    return import_typescript40.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_typescript41.default.factory.createPropertySignature(
+      return import_typescript40.default.factory.createPropertySignature(
         void 0,
-        quoted ? import_typescript41.default.factory.createStringLiteral(key) : key,
+        quoted ? import_typescript40.default.factory.createStringLiteral(key) : key,
         void 0,
         type
       );
     });
-    return import_typescript41.default.factory.createTypeLiteralNode(entries);
+    return import_typescript40.default.factory.createTypeLiteralNode(entries);
   }
   visitCommaExpr(ast, context) {
     throw new Error("Method not implemented.");
   }
   visitWrappedNodeExpr(ast, context) {
     const node = ast.node;
-    if (import_typescript41.default.isEntityName(node)) {
-      return import_typescript41.default.factory.createTypeReferenceNode(node, void 0);
-    } else if (import_typescript41.default.isTypeNode(node)) {
+    if (import_typescript40.default.isEntityName(node)) {
+      return import_typescript40.default.factory.createTypeReferenceNode(node, void 0);
+    } else if (import_typescript40.default.isTypeNode(node)) {
       return node;
-    } else if (import_typescript41.default.isLiteralExpression(node)) {
-      return import_typescript41.default.factory.createLiteralTypeNode(node);
+    } else if (import_typescript40.default.isLiteralExpression(node)) {
+      return import_typescript40.default.factory.createLiteralTypeNode(node);
     } else {
-      throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${import_typescript41.default.SyntaxKind[node.kind]}`);
+      throw new Error(`Unsupported WrappedNodeExpr in TypeTranslatorVisitor: ${import_typescript40.default.SyntaxKind[node.kind]}`);
     }
   }
   visitTypeofExpr(ast, context) {
     const typeNode = this.translateExpression(ast.expr, context);
-    if (!import_typescript41.default.isTypeReferenceNode(typeNode)) {
+    if (!import_typescript40.default.isTypeReferenceNode(typeNode)) {
       throw new Error(`The target of a typeof expression must be a type reference, but it was
-          ${import_typescript41.default.SyntaxKind[typeNode.kind]}`);
+          ${import_typescript40.default.SyntaxKind[typeNode.kind]}`);
     }
-    return import_typescript41.default.factory.createTypeQueryNode(typeNode.typeName);
+    return import_typescript40.default.factory.createTypeQueryNode(typeNode.typeName);
   }
   translateType(type, context) {
     const typeNode = type.visitType(this, context);
-    if (!import_typescript41.default.isTypeNode(typeNode)) {
-      throw new Error(`A Type must translate to a TypeNode, but was ${import_typescript41.default.SyntaxKind[typeNode.kind]}`);
+    if (!import_typescript40.default.isTypeNode(typeNode)) {
+      throw new Error(`A Type must translate to a TypeNode, but was ${import_typescript40.default.SyntaxKind[typeNode.kind]}`);
     }
     return typeNode;
   }
   translateExpression(expr, context) {
     const typeNode = expr.visitExpression(this, context);
-    if (!import_typescript41.default.isTypeNode(typeNode)) {
-      throw new Error(`An Expression must translate to a TypeNode, but was ${import_typescript41.default.SyntaxKind[typeNode.kind]}`);
+    if (!import_typescript40.default.isTypeNode(typeNode)) {
+      throw new Error(`An Expression must translate to a TypeNode, but was ${import_typescript40.default.SyntaxKind[typeNode.kind]}`);
     }
     return typeNode;
   }
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.mjs
-var import_typescript42 = __toESM(require("typescript"), 1);
+var import_typescript41 = __toESM(require("typescript"), 1);
 var PureAnnotation;
 (function(PureAnnotation2) {
   PureAnnotation2["CLOSURE"] = "* @pureOrBreakMyCode ";
   PureAnnotation2["TERSER"] = "@__PURE__";
 })(PureAnnotation || (PureAnnotation = {}));
 var UNARY_OPERATORS3 = {
-  "+": import_typescript42.default.SyntaxKind.PlusToken,
-  "-": import_typescript42.default.SyntaxKind.MinusToken,
-  "!": import_typescript42.default.SyntaxKind.ExclamationToken
+  "+": import_typescript41.default.SyntaxKind.PlusToken,
+  "-": import_typescript41.default.SyntaxKind.MinusToken,
+  "!": import_typescript41.default.SyntaxKind.ExclamationToken
 };
 var BINARY_OPERATORS3 = {
-  "&&": import_typescript42.default.SyntaxKind.AmpersandAmpersandToken,
-  ">": import_typescript42.default.SyntaxKind.GreaterThanToken,
-  ">=": import_typescript42.default.SyntaxKind.GreaterThanEqualsToken,
-  "&": import_typescript42.default.SyntaxKind.AmpersandToken,
-  "/": import_typescript42.default.SyntaxKind.SlashToken,
-  "==": import_typescript42.default.SyntaxKind.EqualsEqualsToken,
-  "===": import_typescript42.default.SyntaxKind.EqualsEqualsEqualsToken,
-  "<": import_typescript42.default.SyntaxKind.LessThanToken,
-  "<=": import_typescript42.default.SyntaxKind.LessThanEqualsToken,
-  "-": import_typescript42.default.SyntaxKind.MinusToken,
-  "%": import_typescript42.default.SyntaxKind.PercentToken,
-  "*": import_typescript42.default.SyntaxKind.AsteriskToken,
-  "!=": import_typescript42.default.SyntaxKind.ExclamationEqualsToken,
-  "!==": import_typescript42.default.SyntaxKind.ExclamationEqualsEqualsToken,
-  "||": import_typescript42.default.SyntaxKind.BarBarToken,
-  "+": import_typescript42.default.SyntaxKind.PlusToken,
-  "??": import_typescript42.default.SyntaxKind.QuestionQuestionToken
+  "&&": import_typescript41.default.SyntaxKind.AmpersandAmpersandToken,
+  ">": import_typescript41.default.SyntaxKind.GreaterThanToken,
+  ">=": import_typescript41.default.SyntaxKind.GreaterThanEqualsToken,
+  "&": import_typescript41.default.SyntaxKind.AmpersandToken,
+  "/": import_typescript41.default.SyntaxKind.SlashToken,
+  "==": import_typescript41.default.SyntaxKind.EqualsEqualsToken,
+  "===": import_typescript41.default.SyntaxKind.EqualsEqualsEqualsToken,
+  "<": import_typescript41.default.SyntaxKind.LessThanToken,
+  "<=": import_typescript41.default.SyntaxKind.LessThanEqualsToken,
+  "-": import_typescript41.default.SyntaxKind.MinusToken,
+  "%": import_typescript41.default.SyntaxKind.PercentToken,
+  "*": import_typescript41.default.SyntaxKind.AsteriskToken,
+  "!=": import_typescript41.default.SyntaxKind.ExclamationEqualsToken,
+  "!==": import_typescript41.default.SyntaxKind.ExclamationEqualsEqualsToken,
+  "||": import_typescript41.default.SyntaxKind.BarBarToken,
+  "+": import_typescript41.default.SyntaxKind.PlusToken,
+  "??": import_typescript41.default.SyntaxKind.QuestionQuestionToken
 };
 var VAR_TYPES = {
-  "const": import_typescript42.default.NodeFlags.Const,
-  "let": import_typescript42.default.NodeFlags.Let,
-  "var": import_typescript42.default.NodeFlags.None
+  "const": import_typescript41.default.NodeFlags.Const,
+  "let": import_typescript41.default.NodeFlags.Let,
+  "var": import_typescript41.default.NodeFlags.None
 };
 var TypeScriptAstFactory = class {
   constructor(annotateForClosureCompiler) {
     this.annotateForClosureCompiler = annotateForClosureCompiler;
     this.externalSourceFiles = /* @__PURE__ */ new Map();
     this.attachComments = attachComments;
-    this.createArrayLiteral = import_typescript42.default.factory.createArrayLiteralExpression;
-    this.createElementAccess = import_typescript42.default.factory.createElementAccessExpression;
-    this.createExpressionStatement = import_typescript42.default.factory.createExpressionStatement;
-    this.createIdentifier = import_typescript42.default.factory.createIdentifier;
-    this.createParenthesizedExpression = import_typescript42.default.factory.createParenthesizedExpression;
-    this.createPropertyAccess = import_typescript42.default.factory.createPropertyAccessExpression;
-    this.createThrowStatement = import_typescript42.default.factory.createThrowStatement;
-    this.createTypeOfExpression = import_typescript42.default.factory.createTypeOfExpression;
+    this.createArrayLiteral = import_typescript41.default.factory.createArrayLiteralExpression;
+    this.createElementAccess = import_typescript41.default.factory.createElementAccessExpression;
+    this.createExpressionStatement = import_typescript41.default.factory.createExpressionStatement;
+    this.createIdentifier = import_typescript41.default.factory.createIdentifier;
+    this.createParenthesizedExpression = import_typescript41.default.factory.createParenthesizedExpression;
+    this.createPropertyAccess = import_typescript41.default.factory.createPropertyAccessExpression;
+    this.createThrowStatement = import_typescript41.default.factory.createThrowStatement;
+    this.createTypeOfExpression = import_typescript41.default.factory.createTypeOfExpression;
   }
   createAssignment(target, value) {
-    return import_typescript42.default.factory.createBinaryExpression(target, import_typescript42.default.SyntaxKind.EqualsToken, value);
+    return import_typescript41.default.factory.createBinaryExpression(target, import_typescript41.default.SyntaxKind.EqualsToken, value);
   }
   createBinaryExpression(leftOperand, operator, rightOperand) {
-    return import_typescript42.default.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS3[operator], rightOperand);
+    return import_typescript41.default.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS3[operator], rightOperand);
   }
   createBlock(body) {
-    return import_typescript42.default.factory.createBlock(body);
+    return import_typescript41.default.factory.createBlock(body);
   }
   createCallExpression(callee, args, pure) {
-    const call = import_typescript42.default.factory.createCallExpression(callee, void 0, args);
+    const call = import_typescript41.default.factory.createCallExpression(callee, void 0, args);
     if (pure) {
-      import_typescript42.default.addSyntheticLeadingComment(
+      import_typescript41.default.addSyntheticLeadingComment(
         call,
-        import_typescript42.default.SyntaxKind.MultiLineCommentTrivia,
+        import_typescript41.default.SyntaxKind.MultiLineCommentTrivia,
         this.annotateForClosureCompiler ? PureAnnotation.CLOSURE : PureAnnotation.TERSER,
         false
       );
@@ -23864,51 +23832,51 @@ var TypeScriptAstFactory = class {
     return call;
   }
   createConditional(condition, whenTrue, whenFalse) {
-    return import_typescript42.default.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
+    return import_typescript41.default.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
   }
   createFunctionDeclaration(functionName, parameters, body) {
-    if (!import_typescript42.default.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript42.default.SyntaxKind[body.kind]}.`);
+    if (!import_typescript41.default.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript41.default.SyntaxKind[body.kind]}.`);
     }
-    return createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return import_typescript41.default.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => import_typescript41.default.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
   }
   createFunctionExpression(functionName, parameters, body) {
-    if (!import_typescript42.default.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript42.default.SyntaxKind[body.kind]}.`);
+    if (!import_typescript41.default.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${import_typescript41.default.SyntaxKind[body.kind]}.`);
     }
-    return import_typescript42.default.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return import_typescript41.default.factory.createFunctionExpression(void 0, void 0, functionName != null ? functionName : void 0, void 0, parameters.map((param) => import_typescript41.default.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
   }
   createIfStatement(condition, thenStatement, elseStatement) {
-    return import_typescript42.default.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
+    return import_typescript41.default.factory.createIfStatement(condition, thenStatement, elseStatement != null ? elseStatement : void 0);
   }
   createLiteral(value) {
     if (value === void 0) {
-      return import_typescript42.default.factory.createIdentifier("undefined");
+      return import_typescript41.default.factory.createIdentifier("undefined");
     } else if (value === null) {
-      return import_typescript42.default.factory.createNull();
+      return import_typescript41.default.factory.createNull();
     } else if (typeof value === "boolean") {
-      return value ? import_typescript42.default.factory.createTrue() : import_typescript42.default.factory.createFalse();
+      return value ? import_typescript41.default.factory.createTrue() : import_typescript41.default.factory.createFalse();
     } else if (typeof value === "number") {
-      return import_typescript42.default.factory.createNumericLiteral(value);
+      return import_typescript41.default.factory.createNumericLiteral(value);
     } else {
-      return import_typescript42.default.factory.createStringLiteral(value);
+      return import_typescript41.default.factory.createStringLiteral(value);
     }
   }
   createNewExpression(expression, args) {
-    return import_typescript42.default.factory.createNewExpression(expression, void 0, args);
+    return import_typescript41.default.factory.createNewExpression(expression, void 0, args);
   }
   createObjectLiteral(properties) {
-    return import_typescript42.default.factory.createObjectLiteralExpression(properties.map((prop) => import_typescript42.default.factory.createPropertyAssignment(prop.quoted ? import_typescript42.default.factory.createStringLiteral(prop.propertyName) : import_typescript42.default.factory.createIdentifier(prop.propertyName), prop.value)));
+    return import_typescript41.default.factory.createObjectLiteralExpression(properties.map((prop) => import_typescript41.default.factory.createPropertyAssignment(prop.quoted ? import_typescript41.default.factory.createStringLiteral(prop.propertyName) : import_typescript41.default.factory.createIdentifier(prop.propertyName), prop.value)));
   }
   createReturnStatement(expression) {
-    return import_typescript42.default.factory.createReturnStatement(expression != null ? expression : void 0);
+    return import_typescript41.default.factory.createReturnStatement(expression != null ? expression : void 0);
   }
   createTaggedTemplate(tag, template) {
     let templateLiteral;
     const length = template.elements.length;
     const head = template.elements[0];
     if (length === 1) {
-      templateLiteral = import_typescript42.default.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+      templateLiteral = import_typescript41.default.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
     } else {
       const spans = [];
       for (let i = 1; i < length - 1; i++) {
@@ -23917,7 +23885,7 @@ var TypeScriptAstFactory = class {
         if (range !== null) {
           this.setSourceMapRange(middle, range);
         }
-        spans.push(import_typescript42.default.factory.createTemplateSpan(template.expressions[i - 1], middle));
+        spans.push(import_typescript41.default.factory.createTemplateSpan(template.expressions[i - 1], middle));
       }
       const resolvedExpression = template.expressions[length - 2];
       const templatePart = template.elements[length - 1];
@@ -23925,19 +23893,19 @@ var TypeScriptAstFactory = class {
       if (templatePart.range !== null) {
         this.setSourceMapRange(templateTail, templatePart.range);
       }
-      spans.push(import_typescript42.default.factory.createTemplateSpan(resolvedExpression, templateTail));
-      templateLiteral = import_typescript42.default.factory.createTemplateExpression(import_typescript42.default.factory.createTemplateHead(head.cooked, head.raw), spans);
+      spans.push(import_typescript41.default.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = import_typescript41.default.factory.createTemplateExpression(import_typescript41.default.factory.createTemplateHead(head.cooked, head.raw), spans);
     }
     if (head.range !== null) {
       this.setSourceMapRange(templateLiteral, head.range);
     }
-    return import_typescript42.default.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
+    return import_typescript41.default.factory.createTaggedTemplateExpression(tag, void 0, templateLiteral);
   }
   createUnaryExpression(operator, operand) {
-    return import_typescript42.default.factory.createPrefixUnaryExpression(UNARY_OPERATORS3[operator], operand);
+    return import_typescript41.default.factory.createPrefixUnaryExpression(UNARY_OPERATORS3[operator], operand);
   }
   createVariableDeclaration(variableName, initializer, type) {
-    return import_typescript42.default.factory.createVariableStatement(void 0, import_typescript42.default.factory.createVariableDeclarationList([import_typescript42.default.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
+    return import_typescript41.default.factory.createVariableStatement(void 0, import_typescript41.default.factory.createVariableDeclarationList([import_typescript41.default.factory.createVariableDeclaration(variableName, void 0, void 0, initializer != null ? initializer : void 0)], VAR_TYPES[type]));
   }
   setSourceMapRange(node, sourceMapRange) {
     if (sourceMapRange === null) {
@@ -23945,31 +23913,31 @@ var TypeScriptAstFactory = class {
     }
     const url = sourceMapRange.url;
     if (!this.externalSourceFiles.has(url)) {
-      this.externalSourceFiles.set(url, import_typescript42.default.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+      this.externalSourceFiles.set(url, import_typescript41.default.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
     }
     const source = this.externalSourceFiles.get(url);
-    import_typescript42.default.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
+    import_typescript41.default.setSourceMapRange(node, { pos: sourceMapRange.start.offset, end: sourceMapRange.end.offset, source });
     return node;
   }
 };
 function createTemplateMiddle(cooked, raw) {
-  const node = import_typescript42.default.factory.createTemplateHead(cooked, raw);
-  node.kind = import_typescript42.default.SyntaxKind.TemplateMiddle;
+  const node = import_typescript41.default.factory.createTemplateHead(cooked, raw);
+  node.kind = import_typescript41.default.SyntaxKind.TemplateMiddle;
   return node;
 }
 function createTemplateTail(cooked, raw) {
-  const node = import_typescript42.default.factory.createTemplateHead(cooked, raw);
-  node.kind = import_typescript42.default.SyntaxKind.TemplateTail;
+  const node = import_typescript41.default.factory.createTemplateHead(cooked, raw);
+  node.kind = import_typescript41.default.SyntaxKind.TemplateTail;
   return node;
 }
 function attachComments(statement, leadingComments) {
   for (const comment of leadingComments) {
-    const commentKind = comment.multiline ? import_typescript42.default.SyntaxKind.MultiLineCommentTrivia : import_typescript42.default.SyntaxKind.SingleLineCommentTrivia;
+    const commentKind = comment.multiline ? import_typescript41.default.SyntaxKind.MultiLineCommentTrivia : import_typescript41.default.SyntaxKind.SingleLineCommentTrivia;
     if (comment.multiline) {
-      import_typescript42.default.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+      import_typescript41.default.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
     } else {
       for (const line of comment.toString().split("\n")) {
-        import_typescript42.default.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+        import_typescript41.default.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
       }
     }
   }
@@ -23984,28 +23952,28 @@ function translateStatement(statement, imports, options = {}) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/utils.mjs
-var import_typescript43 = __toESM(require("typescript"), 1);
+var import_typescript42 = __toESM(require("typescript"), 1);
 function addImports(importManager, sf, extraStatements = []) {
   const addedImports = importManager.getAllImports(sf.fileName).map((i) => {
-    const qualifier = import_typescript43.default.factory.createIdentifier(i.qualifier.text);
-    const importClause = import_typescript43.default.factory.createImportClause(
+    const qualifier = import_typescript42.default.factory.createIdentifier(i.qualifier.text);
+    const importClause = import_typescript42.default.factory.createImportClause(
       false,
       void 0,
-      import_typescript43.default.factory.createNamespaceImport(qualifier)
+      import_typescript42.default.factory.createNamespaceImport(qualifier)
     );
-    const decl = createImportDeclaration(
+    const decl = import_typescript42.default.factory.createImportDeclaration(
       void 0,
       importClause,
-      import_typescript43.default.factory.createStringLiteral(i.specifier)
+      import_typescript42.default.factory.createStringLiteral(i.specifier)
     );
-    import_typescript43.default.setOriginalNode(i.qualifier, decl);
+    import_typescript42.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_typescript43.default.factory.createNotEmittedStatement(sf);
-    return import_typescript43.default.factory.updateSourceFile(sf, import_typescript43.default.factory.createNodeArray([
+    const fileoverviewAnchorStmt = import_typescript42.default.factory.createNotEmittedStatement(sf);
+    return import_typescript42.default.factory.updateSourceFile(sf, import_typescript42.default.factory.createNodeArray([
       fileoverviewAnchorStmt,
       ...existingImports,
       ...addedImports,
@@ -24016,7 +23984,7 @@ function addImports(importManager, sf, extraStatements = []) {
   return sf;
 }
 function isImportStatement(stmt) {
-  return import_typescript43.default.isImportDeclaration(stmt) || import_typescript43.default.isImportEqualsDeclaration(stmt) || import_typescript43.default.isNamespaceImport(stmt);
+  return import_typescript42.default.isImportDeclaration(stmt) || import_typescript42.default.isImportEqualsDeclaration(stmt) || import_typescript42.default.isNamespaceImport(stmt);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/declaration.mjs
@@ -24034,7 +24002,7 @@ var DtsTransformRegistry = class {
     if (!sf.isDeclarationFile) {
       return null;
     }
-    const originalSf = import_typescript44.default.getOriginalNode(sf);
+    const originalSf = import_typescript43.default.getOriginalNode(sf);
     let transforms = null;
     if (this.ivyDeclarationTransforms.has(originalSf)) {
       transforms = [];
@@ -24047,7 +24015,7 @@ function declarationTransformFactory(transformRegistry, importRewriter, importPr
   return (context) => {
     const transformer = new DtsTransformer(context, importRewriter, importPrefix);
     return (fileOrBundle) => {
-      if (import_typescript44.default.isBundle(fileOrBundle)) {
+      if (import_typescript43.default.isBundle(fileOrBundle)) {
         return fileOrBundle;
       }
       const transforms = transformRegistry.getAllTransforms(fileOrBundle);
@@ -24067,15 +24035,15 @@ var DtsTransformer = class {
   transform(sf, transforms) {
     const imports = new ImportManager(this.importRewriter, this.importPrefix);
     const visitor = (node) => {
-      if (import_typescript44.default.isClassDeclaration(node)) {
+      if (import_typescript43.default.isClassDeclaration(node)) {
         return this.transformClassDeclaration(node, transforms, imports);
-      } else if (import_typescript44.default.isFunctionDeclaration(node)) {
+      } else if (import_typescript43.default.isFunctionDeclaration(node)) {
         return this.transformFunctionDeclaration(node, transforms, imports);
       } else {
-        return import_typescript44.default.visitEachChild(node, visitor, this.ctx);
+        return import_typescript43.default.visitEachChild(node, visitor, this.ctx);
       }
     };
-    sf = import_typescript44.default.visitNode(sf, visitor);
+    sf = import_typescript43.default.visitNode(sf, visitor, import_typescript43.default.isSourceFile) || sf;
     return addImports(imports, sf);
   }
   transformClassDeclaration(clazz, transforms, imports) {
@@ -24103,7 +24071,7 @@ var DtsTransformer = class {
       }
     }
     if (elementsChanged && clazz === newClazz) {
-      newClazz = import_typescript44.default.factory.updateClassDeclaration(
+      newClazz = import_typescript43.default.factory.updateClassDeclaration(
         clazz,
         clazz.modifiers,
         clazz.name,
@@ -24132,16 +24100,16 @@ var IvyDeclarationDtsTransform = class {
     this.declarationFields.set(decl, fields);
   }
   transformClass(clazz, members, imports) {
-    const original = import_typescript44.default.getOriginalNode(clazz);
+    const original = import_typescript43.default.getOriginalNode(clazz);
     if (!this.declarationFields.has(original)) {
       return clazz;
     }
     const fields = this.declarationFields.get(original);
     const newMembers = fields.map((decl) => {
-      const modifiers = [import_typescript44.default.factory.createModifier(import_typescript44.default.SyntaxKind.StaticKeyword)];
+      const modifiers = [import_typescript43.default.factory.createModifier(import_typescript43.default.SyntaxKind.StaticKeyword)];
       const typeRef = translateType(decl.type, imports);
       markForEmitAsSingleLine(typeRef);
-      return import_typescript44.default.factory.createPropertyDeclaration(
+      return import_typescript43.default.factory.createPropertyDeclaration(
         modifiers,
         decl.name,
         void 0,
@@ -24149,7 +24117,7 @@ var IvyDeclarationDtsTransform = class {
         void 0
       );
     });
-    return import_typescript44.default.factory.updateClassDeclaration(
+    return import_typescript43.default.factory.updateClassDeclaration(
       clazz,
       clazz.modifiers,
       clazz.name,
@@ -24160,15 +24128,15 @@ var IvyDeclarationDtsTransform = class {
   }
 };
 function markForEmitAsSingleLine(node) {
-  import_typescript44.default.setEmitFlags(node, import_typescript44.default.EmitFlags.SingleLine);
-  import_typescript44.default.forEachChild(node, markForEmitAsSingleLine);
+  import_typescript43.default.setEmitFlags(node, import_typescript43.default.EmitFlags.SingleLine);
+  import_typescript43.default.forEachChild(node, markForEmitAsSingleLine);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/transform.mjs
-var import_typescript46 = __toESM(require("typescript"), 1);
+var import_typescript45 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/util/src/visitor.mjs
-var import_typescript45 = __toESM(require("typescript"), 1);
+var import_typescript44 = __toESM(require("typescript"), 1);
 function visit(node, visitor, context) {
   return visitor._visit(node, context);
 }
@@ -24192,13 +24160,13 @@ var Visitor = class {
   }
   _visit(node, context) {
     let visitedNode = null;
-    node = import_typescript45.default.visitEachChild(node, (child) => this._visit(child, context), context);
-    if (import_typescript45.default.isClassDeclaration(node)) {
+    node = import_typescript44.default.visitEachChild(node, (child) => this._visit(child, context), context);
+    if (import_typescript44.default.isClassDeclaration(node)) {
       visitedNode = this._visitListEntryNode(node, (node2) => this.visitClassDeclaration(node2));
     } else {
       visitedNode = this.visitOtherNode(node);
     }
-    if (import_typescript45.default.isBlock(visitedNode) || import_typescript45.default.isSourceFile(visitedNode)) {
+    if (import_typescript44.default.isBlock(visitedNode) || import_typescript44.default.isSourceFile(visitedNode)) {
       visitedNode = this._maybeProcessStatements(visitedNode);
     }
     return visitedNode;
@@ -24219,11 +24187,11 @@ var Visitor = class {
         this._after.delete(stmt);
       }
     });
-    const statementsArray = import_typescript45.default.factory.createNodeArray(newStatements, node.statements.hasTrailingComma);
-    if (import_typescript45.default.isBlock(node)) {
-      return import_typescript45.default.factory.updateBlock(node, statementsArray);
+    const statementsArray = import_typescript44.default.factory.createNodeArray(newStatements, node.statements.hasTrailingComma);
+    if (import_typescript44.default.isBlock(node)) {
+      return import_typescript44.default.factory.updateBlock(node, statementsArray);
     } else {
-      return import_typescript45.default.factory.updateSourceFile(node, statementsArray, node.isDeclarationFile, node.referencedFiles, node.typeReferenceDirectives, node.hasNoDefaultLib, node.libReferenceDirectives);
+      return import_typescript44.default.factory.updateSourceFile(node, statementsArray, node.isDeclarationFile, node.referencedFiles, node.typeReferenceDirectives, node.hasNoDefaultLib, node.libReferenceDirectives);
     }
   }
 };
@@ -24277,11 +24245,11 @@ var IvyTransformationVisitor = class extends Visitor {
     const members = [...node.members];
     for (const field of this.classCompilationMap.get(node)) {
       const exprNode = translateExpression(field.initializer, this.importManager, translateOptions);
-      const property = import_typescript46.default.factory.createPropertyDeclaration([import_typescript46.default.factory.createToken(import_typescript46.default.SyntaxKind.StaticKeyword)], field.name, void 0, void 0, exprNode);
+      const property = import_typescript45.default.factory.createPropertyDeclaration([import_typescript45.default.factory.createToken(import_typescript45.default.SyntaxKind.StaticKeyword)], field.name, void 0, void 0, exprNode);
       if (this.isClosureCompilerEnabled) {
-        import_typescript46.default.addSyntheticLeadingComment(
+        import_typescript45.default.addSyntheticLeadingComment(
           property,
-          import_typescript46.default.SyntaxKind.MultiLineCommentTrivia,
+          import_typescript45.default.SyntaxKind.MultiLineCommentTrivia,
           "* @nocollapse ",
           false
         );
@@ -24289,13 +24257,13 @@ var IvyTransformationVisitor = class extends Visitor {
       field.statements.map((stmt) => translateStatement(stmt, this.importManager, translateOptions)).forEach((stmt) => statements.push(stmt));
       members.push(property);
     }
-    const filteredDecorators = maybeFilterDecorator(import_typescript46.default.getDecorators(node), this.compilation.decoratorsFor(node));
-    const nodeModifiers = import_typescript46.default.getModifiers(node);
+    const filteredDecorators = maybeFilterDecorator(import_typescript45.default.getDecorators(node), this.compilation.decoratorsFor(node));
+    const nodeModifiers = import_typescript45.default.getModifiers(node);
     let updatedModifiers;
     if ((filteredDecorators == null ? void 0 : filteredDecorators.length) || (nodeModifiers == null ? void 0 : nodeModifiers.length)) {
       updatedModifiers = [...filteredDecorators || [], ...nodeModifiers || []];
     }
-    node = import_typescript46.default.factory.updateClassDeclaration(
+    node = import_typescript45.default.factory.updateClassDeclaration(
       node,
       updatedModifiers,
       node.name,
@@ -24318,7 +24286,7 @@ var IvyTransformationVisitor = class extends Visitor {
     }
   }
   _nonCoreDecoratorsOnly(node) {
-    const decorators = import_typescript46.default.getDecorators(node);
+    const decorators = import_typescript45.default.getDecorators(node);
     if (decorators === void 0) {
       return void 0;
     }
@@ -24335,22 +24303,22 @@ var IvyTransformationVisitor = class extends Visitor {
     return nodeArrayFromDecoratorsArray(filtered);
   }
   _stripAngularDecorators(node) {
-    const modifiers = import_typescript46.default.canHaveModifiers(node) ? import_typescript46.default.getModifiers(node) : void 0;
-    const nonCoreDecorators = import_typescript46.default.canHaveDecorators(node) ? this._nonCoreDecoratorsOnly(node) : void 0;
+    const modifiers = import_typescript45.default.canHaveModifiers(node) ? import_typescript45.default.getModifiers(node) : void 0;
+    const nonCoreDecorators = import_typescript45.default.canHaveDecorators(node) ? this._nonCoreDecoratorsOnly(node) : void 0;
     const combinedModifiers = [...nonCoreDecorators || [], ...modifiers || []];
-    if (import_typescript46.default.isParameter(node)) {
-      node = import_typescript46.default.factory.updateParameterDeclaration(node, combinedModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
-    } else if (import_typescript46.default.isMethodDeclaration(node)) {
-      node = import_typescript46.default.factory.updateMethodDeclaration(node, combinedModifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
-    } else if (import_typescript46.default.isPropertyDeclaration(node)) {
-      node = import_typescript46.default.factory.updatePropertyDeclaration(node, combinedModifiers, node.name, node.questionToken, node.type, node.initializer);
-    } else if (import_typescript46.default.isGetAccessor(node)) {
-      node = import_typescript46.default.factory.updateGetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.type, node.body);
-    } else if (import_typescript46.default.isSetAccessor(node)) {
-      node = import_typescript46.default.factory.updateSetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.body);
-    } else if (import_typescript46.default.isConstructorDeclaration(node)) {
+    if (import_typescript45.default.isParameter(node)) {
+      node = import_typescript45.default.factory.updateParameterDeclaration(node, combinedModifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+    } else if (import_typescript45.default.isMethodDeclaration(node)) {
+      node = import_typescript45.default.factory.updateMethodDeclaration(node, combinedModifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
+    } else if (import_typescript45.default.isPropertyDeclaration(node)) {
+      node = import_typescript45.default.factory.updatePropertyDeclaration(node, combinedModifiers, node.name, node.questionToken, node.type, node.initializer);
+    } else if (import_typescript45.default.isGetAccessor(node)) {
+      node = import_typescript45.default.factory.updateGetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.type, node.body);
+    } else if (import_typescript45.default.isSetAccessor(node)) {
+      node = import_typescript45.default.factory.updateSetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.body);
+    } else if (import_typescript45.default.isConstructorDeclaration(node)) {
       const parameters = node.parameters.map((param) => this._stripAngularDecorators(param));
-      node = import_typescript46.default.factory.updateConstructorDeclaration(node, modifiers, parameters, node.body);
+      node = import_typescript45.default.factory.updateConstructorDeclaration(node, modifiers, parameters, node.body);
     }
     return node;
   }
@@ -24362,7 +24330,7 @@ function transformIvySourceFile(compilation, context, reflector, importRewriter,
   visit(file, compilationVisitor, context);
   const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore);
   let sf = visit(file, transformationVisitor, context);
-  const downlevelTranslatedCode = getLocalizeCompileTarget(context) < import_typescript46.default.ScriptTarget.ES2015;
+  const downlevelTranslatedCode = getLocalizeCompileTarget(context) < import_typescript45.default.ScriptTarget.ES2015;
   const constants = constantPool.statements.map((stmt) => translateStatement(stmt, importManager, {
     recordWrappedNode,
     downlevelTaggedTemplates: downlevelTranslatedCode,
@@ -24377,17 +24345,17 @@ function transformIvySourceFile(compilation, context, reflector, importRewriter,
   return sf;
 }
 function getLocalizeCompileTarget(context) {
-  const target = context.getCompilerOptions().target || import_typescript46.default.ScriptTarget.ES2015;
-  return target !== import_typescript46.default.ScriptTarget.JSON ? target : import_typescript46.default.ScriptTarget.ES2015;
+  const target = context.getCompilerOptions().target || import_typescript45.default.ScriptTarget.ES2015;
+  return target !== import_typescript45.default.ScriptTarget.JSON ? target : import_typescript45.default.ScriptTarget.ES2015;
 }
 function getFileOverviewComment(statements) {
   if (statements.length > 0) {
     const host = statements[0];
     let trailing = false;
-    let comments = import_typescript46.default.getSyntheticLeadingComments(host);
+    let comments = import_typescript45.default.getSyntheticLeadingComments(host);
     if (!comments || comments.length === 0) {
       trailing = true;
-      comments = import_typescript46.default.getSyntheticTrailingComments(host);
+      comments = import_typescript45.default.getSyntheticTrailingComments(host);
     }
     if (comments && comments.length > 0 && CLOSURE_FILE_OVERVIEW_REGEXP.test(comments[0].text)) {
       return { comments, host, trailing };
@@ -24399,22 +24367,22 @@ function setFileOverviewComment(sf, fileoverview) {
   const { comments, host, trailing } = fileoverview;
   if (sf.statements.length > 0 && host !== sf.statements[0]) {
     if (trailing) {
-      import_typescript46.default.setSyntheticTrailingComments(host, void 0);
+      import_typescript45.default.setSyntheticTrailingComments(host, void 0);
     } else {
-      import_typescript46.default.setSyntheticLeadingComments(host, void 0);
+      import_typescript45.default.setSyntheticLeadingComments(host, void 0);
     }
-    import_typescript46.default.setSyntheticLeadingComments(sf.statements[0], comments);
+    import_typescript45.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_typescript46.default.getOriginalNode(dec) === decToRemove) === void 0);
+  const filtered = decorators.filter((dec) => toRemove.find((decToRemove) => import_typescript45.default.getOriginalNode(dec) === decToRemove) === void 0);
   if (filtered.length === 0) {
     return void 0;
   }
-  return import_typescript46.default.factory.createNodeArray(filtered);
+  return import_typescript45.default.factory.createNodeArray(filtered);
 }
 function isFromAngularCore(decorator) {
   return decorator.import !== null && decorator.import.from === "@angular/core";
@@ -24428,7 +24396,7 @@ function createRecorderFn(defaultImportTracker) {
   };
 }
 function nodeArrayFromDecoratorsArray(decorators) {
-  const array = import_typescript46.default.factory.createNodeArray(decorators);
+  const array = import_typescript45.default.factory.createNodeArray(decorators);
   if (array.length > 0) {
     array.pos = decorators[0].pos;
     array.end = decorators[decorators.length - 1].end;
@@ -24437,7 +24405,7 @@ function nodeArrayFromDecoratorsArray(decorators) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.mjs
-var import_typescript47 = __toESM(require("typescript"), 1);
+var import_typescript46 = __toESM(require("typescript"), 1);
 var EMPTY_OBJECT = {};
 var QUERY_TYPES = /* @__PURE__ */ new Set([
   "ContentChild",
@@ -24453,7 +24421,7 @@ function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, refEmi
     throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @${decorator.name} decorator`);
   } else {
     const meta = unwrapExpression(decorator.args[0]);
-    if (!import_typescript47.default.isObjectLiteralExpression(meta)) {
+    if (!import_typescript46.default.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, `@${decorator.name} argument must be an object literal`);
     }
     directive = reflectObjectLiteral(meta);
@@ -24580,7 +24548,7 @@ function extractQueryMetadata(exprNode, name, args, propertyName, reflector, eva
   let emitDistinctChangesOnly = emitDistinctChangesOnlyDefaultValue;
   if (args.length === 2) {
     const optionsExpr = unwrapExpression(args[1]);
-    if (!import_typescript47.default.isObjectLiteralExpression(optionsExpr)) {
+    if (!import_typescript46.default.isObjectLiteralExpression(optionsExpr)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, optionsExpr, `@${name} options must be an object literal`);
     }
     const options = reflectObjectLiteral(optionsExpr);
@@ -24675,16 +24643,16 @@ function extractHostBindings2(members, evaluator, coreModule, metadata) {
 }
 function extractQueriesFromDecorator(queryData, reflector, evaluator, isCore) {
   const content = [], view = [];
-  if (!import_typescript47.default.isObjectLiteralExpression(queryData)) {
+  if (!import_typescript46.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_typescript47.default.isNewExpression(queryExpr)) {
+    if (!import_typescript46.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_typescript47.default.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
-    if (!import_typescript47.default.isIdentifier(queryType)) {
+    const queryType = import_typescript46.default.isPropertyAccessExpression(queryExpr.expression) ? queryExpr.expression.name : queryExpr.expression;
+    if (!import_typescript46.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);
@@ -25089,16 +25057,16 @@ var DirectiveDecoratorHandler = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.mjs
-var import_typescript49 = __toESM(require("typescript"), 1);
+var import_typescript48 = __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_typescript48 = __toESM(require("typescript"), 1);
+var import_typescript47 = __toESM(require("typescript"), 1);
 function createModuleWithProvidersResolver(reflector, isCore) {
   function _reflectModuleFromTypeParam(type, node) {
-    if (!import_typescript48.default.isTypeReferenceNode(type)) {
+    if (!import_typescript47.default.isTypeReferenceNode(type)) {
       return null;
     }
-    const typeName = type && (import_typescript48.default.isIdentifier(type.typeName) && type.typeName || import_typescript48.default.isQualifiedName(type.typeName) && type.typeName.right) || null;
+    const typeName = type && (import_typescript47.default.isIdentifier(type.typeName) && type.typeName || import_typescript47.default.isQualifiedName(type.typeName) && type.typeName.right) || null;
     if (typeName === null) {
       return null;
     }
@@ -25110,7 +25078,7 @@ function createModuleWithProvidersResolver(reflector, isCore) {
       return null;
     }
     if (type.typeArguments === void 0 || type.typeArguments.length !== 1) {
-      const parent = import_typescript48.default.isMethodDeclaration(node) && import_typescript48.default.isClassDeclaration(node.parent) ? node.parent : null;
+      const parent = import_typescript47.default.isMethodDeclaration(node) && import_typescript47.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.`);
     }
@@ -25118,13 +25086,13 @@ function createModuleWithProvidersResolver(reflector, isCore) {
     return typeNodeToValueExpr(arg);
   }
   function _reflectModuleFromLiteralType(type) {
-    if (!import_typescript48.default.isIntersectionTypeNode(type)) {
+    if (!import_typescript47.default.isIntersectionTypeNode(type)) {
       return null;
     }
     for (const t of type.types) {
-      if (import_typescript48.default.isTypeLiteralNode(t)) {
+      if (import_typescript47.default.isTypeLiteralNode(t)) {
         for (const m of t.members) {
-          const ngModuleType = import_typescript48.default.isPropertySignature(m) && import_typescript48.default.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
+          const ngModuleType = import_typescript47.default.isPropertySignature(m) && import_typescript47.default.isIdentifier(m.name) && m.name.text === "ngModule" && m.type || null;
           const ngModuleExpression = ngModuleType && typeNodeToValueExpr(ngModuleType);
           if (ngModuleExpression) {
             return ngModuleExpression;
@@ -25242,8 +25210,8 @@ var NgModuleDecoratorHandler = class {
     if (decorator.args === null || decorator.args.length > 1) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @NgModule decorator`);
     }
-    const meta = decorator.args.length === 1 ? unwrapExpression(decorator.args[0]) : import_typescript49.default.factory.createObjectLiteralExpression([]);
-    if (!import_typescript49.default.isObjectLiteralExpression(meta)) {
+    const meta = decorator.args.length === 1 ? unwrapExpression(decorator.args[0]) : import_typescript48.default.factory.createObjectLiteralExpression([]);
+    if (!import_typescript48.default.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@NgModule argument must be an object literal");
     }
     const ngModule = reflectObjectLiteral(meta);
@@ -25306,7 +25274,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_typescript49.default.DiagnosticCategory.Warning;
+        diag.category = import_typescript48.default.DiagnosticCategory.Warning;
         diagnostics.push(diag);
       }
     }
@@ -25351,16 +25319,16 @@ var NgModuleDecoratorHandler = class {
     };
     const rawProviders = ngModule.has("providers") ? ngModule.get("providers") : null;
     let wrappedProviders = null;
-    if (rawProviders !== null && (!import_typescript49.default.isArrayLiteralExpression(rawProviders) || rawProviders.elements.length > 0)) {
+    if (rawProviders !== null && (!import_typescript48.default.isArrayLiteralExpression(rawProviders) || rawProviders.elements.length > 0)) {
       wrappedProviders = new WrappedNodeExpr(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(rawProviders) : rawProviders);
     }
     const topLevelImports = [];
     if (ngModule.has("imports")) {
       const rawImports2 = unwrapExpression(ngModule.get("imports"));
       let topLevelExpressions = [];
-      if (import_typescript49.default.isArrayLiteralExpression(rawImports2)) {
+      if (import_typescript48.default.isArrayLiteralExpression(rawImports2)) {
         for (const element of rawImports2.elements) {
-          if (import_typescript49.default.isSpreadElement(element)) {
+          if (import_typescript48.default.isSpreadElement(element)) {
             topLevelExpressions.push(element.expression);
             continue;
           }
@@ -25642,7 +25610,7 @@ function isNgModule(node, compilation) {
   return !compilation.dependencies.some((dep) => dep.ref.node === node);
 }
 function isModuleIdExpression(expr) {
-  return import_typescript49.default.isPropertyAccessExpression(expr) && import_typescript49.default.isIdentifier(expr.expression) && expr.expression.text === "module" && expr.name.text === "id";
+  return import_typescript48.default.isPropertyAccessExpression(expr) && import_typescript48.default.isIdentifier(expr.expression) && expr.expression.text === "module" && expr.name.text === "id";
 }
 function makeStandaloneBootstrapDiagnostic(ngModuleClass, bootstrappedClassRef, rawBootstrapExpr) {
   const componentClassName = bootstrappedClassRef.node.name.text;
@@ -25678,7 +25646,7 @@ function checkCustomElementSelectorForErrors(selector) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/resources.mjs
-var import_typescript51 = __toESM(require("typescript"), 1);
+var import_typescript50 = __toESM(require("typescript"), 1);
 function getTemplateDeclarationNodeForError(declaration) {
   switch (declaration.isInline) {
     case true:
@@ -25695,7 +25663,7 @@ function extractTemplate(node, template, evaluator, depTracker, resourceLoader,
     let sourceMapping;
     let escapedString = false;
     let sourceMapUrl;
-    if (import_typescript51.default.isStringLiteral(template.expression) || import_typescript51.default.isNoSubstitutionTemplateLiteral(template.expression)) {
+    if (import_typescript50.default.isStringLiteral(template.expression) || import_typescript50.default.isNoSubstitutionTemplateLiteral(template.expression)) {
       sourceParseRange = getTemplateRange(template.expression);
       sourceStr = template.expression.getSourceFile().text;
       templateContent = template.expression.text;
@@ -25777,7 +25745,7 @@ function parseExtractedTemplate(template, sourceStr, sourceParseRange, escapedSt
     file: new ParseSourceFile(sourceStr, sourceMapUrl != null ? sourceMapUrl : "")
   });
 }
-function parseTemplateDeclaration(decorator, component, containingFile, evaluator, resourceLoader, defaultPreserveWhitespaces) {
+function parseTemplateDeclaration(node, decorator, component, containingFile, evaluator, depTracker, resourceLoader, defaultPreserveWhitespaces) {
   let preserveWhitespaces = defaultPreserveWhitespaces;
   if (component.has("preserveWhitespaces")) {
     const expr = component.get("preserveWhitespaces");
@@ -25813,6 +25781,9 @@ function parseTemplateDeclaration(decorator, component, containingFile, evaluato
         resolvedTemplateUrl: resourceUrl
       };
     } catch (e) {
+      if (depTracker !== null) {
+        depTracker.recordDependencyAnalysisFailure(node.getSourceFile());
+      }
       throw makeResourceNotFoundError(templateUrl, templateUrlExpr, 0);
     }
   } else if (component.has("template")) {
@@ -25840,7 +25811,7 @@ function preloadAndParseTemplate(evaluator, resourceLoader, depTracker, preanaly
       const templatePromise = resourceLoader.preload(resourceUrl, { type: "template", containingFile });
       if (templatePromise !== void 0) {
         return templatePromise.then(() => {
-          const templateDecl = parseTemplateDeclaration(decorator, component, containingFile, evaluator, resourceLoader, defaultPreserveWhitespaces);
+          const templateDecl = parseTemplateDeclaration(node, decorator, component, containingFile, evaluator, depTracker, resourceLoader, defaultPreserveWhitespaces);
           const template = extractTemplate(node, templateDecl, evaluator, depTracker, resourceLoader, options);
           preanalyzeTemplateCache.set(node, template);
           return template;
@@ -25849,10 +25820,13 @@ function preloadAndParseTemplate(evaluator, resourceLoader, depTracker, preanaly
         return Promise.resolve(null);
       }
     } catch (e) {
+      if (depTracker !== null) {
+        depTracker.recordDependencyAnalysisFailure(node.getSourceFile());
+      }
       throw makeResourceNotFoundError(templateUrl, templateUrlExpr, 0);
     }
   } else {
-    const templateDecl = parseTemplateDeclaration(decorator, component, containingFile, evaluator, resourceLoader, defaultPreserveWhitespaces);
+    const templateDecl = parseTemplateDeclaration(node, decorator, component, containingFile, evaluator, depTracker, resourceLoader, defaultPreserveWhitespaces);
     const template = extractTemplate(node, templateDecl, evaluator, depTracker, resourceLoader, options);
     preanalyzeTemplateCache.set(node, template);
     return Promise.resolve(template);
@@ -25860,7 +25834,7 @@ function preloadAndParseTemplate(evaluator, resourceLoader, depTracker, preanaly
 }
 function getTemplateRange(templateExpr) {
   const startPos = templateExpr.getStart() + 1;
-  const { line, character } = import_typescript51.default.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
+  const { line, character } = import_typescript50.default.getLineAndCharacterOfPosition(templateExpr.getSourceFile(), startPos);
   return {
     startPos,
     startLine: line,
@@ -25893,7 +25867,7 @@ function transformDecoratorResources(dec, component, styles, template) {
   const metadata = new Map(component);
   if (metadata.has("templateUrl")) {
     metadata.delete("templateUrl");
-    metadata.set("template", import_typescript51.default.factory.createStringLiteral(template.content));
+    metadata.set("template", import_typescript50.default.factory.createStringLiteral(template.content));
   }
   if (metadata.has("styleUrls") || metadata.has("styles")) {
     metadata.delete("styles");
@@ -25901,20 +25875,20 @@ function transformDecoratorResources(dec, component, styles, template) {
     if (styles.length > 0) {
       const styleNodes = styles.reduce((result, style) => {
         if (style.trim().length > 0) {
-          result.push(import_typescript51.default.factory.createStringLiteral(style));
+          result.push(import_typescript50.default.factory.createStringLiteral(style));
         }
         return result;
       }, []);
       if (styleNodes.length > 0) {
-        metadata.set("styles", import_typescript51.default.factory.createArrayLiteralExpression(styleNodes));
+        metadata.set("styles", import_typescript50.default.factory.createArrayLiteralExpression(styleNodes));
       }
     }
   }
   const newMetadataFields = [];
   for (const [name, value] of metadata.entries()) {
-    newMetadataFields.push(import_typescript51.default.factory.createPropertyAssignment(name, value));
+    newMetadataFields.push(import_typescript50.default.factory.createPropertyAssignment(name, value));
   }
-  return __spreadProps(__spreadValues({}, dec), { args: [import_typescript51.default.factory.createObjectLiteralExpression(newMetadataFields)] });
+  return __spreadProps(__spreadValues({}, dec), { args: [import_typescript50.default.factory.createObjectLiteralExpression(newMetadataFields)] });
 }
 function extractComponentStyleUrls(evaluator, component) {
   if (!component.has("styleUrls")) {
@@ -25924,9 +25898,9 @@ function extractComponentStyleUrls(evaluator, component) {
 }
 function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
   const styleUrls = [];
-  if (import_typescript51.default.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (import_typescript50.default.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const styleUrlExpr of styleUrlsExpr.elements) {
-      if (import_typescript51.default.isSpreadElement(styleUrlExpr)) {
+      if (import_typescript50.default.isSpreadElement(styleUrlExpr)) {
         styleUrls.push(...extractStyleUrlsFromExpression(evaluator, styleUrlExpr.expression));
       } else {
         const styleUrl = evaluator.evaluate(styleUrlExpr);
@@ -25958,10 +25932,10 @@ function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
 function extractStyleResources(resourceLoader, component, containingFile) {
   const styles = /* @__PURE__ */ new Set();
   function stringLiteralElements(array) {
-    return array.elements.filter((e) => import_typescript51.default.isStringLiteralLike(e));
+    return array.elements.filter((e) => import_typescript50.default.isStringLiteralLike(e));
   }
   const styleUrlsExpr = component.get("styleUrls");
-  if (styleUrlsExpr !== void 0 && import_typescript51.default.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (styleUrlsExpr !== void 0 && import_typescript50.default.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const expression of stringLiteralElements(styleUrlsExpr)) {
       try {
         const resourceUrl = resourceLoader.resolve(expression.text, containingFile);
@@ -25971,7 +25945,7 @@ function extractStyleResources(resourceLoader, component, containingFile) {
     }
   }
   const stylesExpr = component.get("styles");
-  if (stylesExpr !== void 0 && import_typescript51.default.isArrayLiteralExpression(stylesExpr)) {
+  if (stylesExpr !== void 0 && import_typescript50.default.isArrayLiteralExpression(stylesExpr)) {
     for (const expression of stringLiteralElements(stylesExpr)) {
       styles.add({ path: null, expression });
     }
@@ -26282,7 +26256,7 @@ var ComponentDecoratorHandler = class {
       this.preanalyzeTemplateCache.delete(node);
       template = preanalyzed;
     } else {
-      const templateDecl = parseTemplateDeclaration(decorator, component, containingFile, this.evaluator, this.resourceLoader, this.defaultPreserveWhitespaces);
+      const templateDecl = parseTemplateDeclaration(node, decorator, component, containingFile, this.evaluator, this.depTracker, this.resourceLoader, this.defaultPreserveWhitespaces);
       template = extractTemplate(node, templateDecl, this.evaluator, this.depTracker, this.resourceLoader, {
         enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
         i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
@@ -26308,6 +26282,9 @@ var ComponentDecoratorHandler = class {
           this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(resourceUrl));
         }
       } catch (e) {
+        if (this.depTracker !== null) {
+          this.depTracker.recordDependencyAnalysisFailure(node.getSourceFile());
+        }
         if (diagnostics === void 0) {
           diagnostics = [];
         }
@@ -26455,7 +26432,7 @@ var ComponentDecoratorHandler = class {
     });
   }
   typeCheck(ctx, node, meta) {
-    if (this.typeCheckScopeRegistry === null || !import_typescript52.default.isClassDeclaration(node)) {
+    if (this.typeCheckScopeRegistry === null || !import_typescript51.default.isClassDeclaration(node)) {
       return;
     }
     if (meta.isPoisoned && !this.usePoisonedData) {
@@ -26741,7 +26718,7 @@ function validateStandaloneImports(importRefs, importExpr2, metaReader, scopeRea
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/injectable.mjs
-var import_typescript54 = __toESM(require("typescript"), 1);
+var import_typescript53 = __toESM(require("typescript"), 1);
 var InjectableDecoratorHandler = class {
   constructor(reflector, evaluator, isCore, strictCtorDeps, injectableRegistry, perf, errorOnDuplicateProv = true) {
     this.reflector = reflector;
@@ -26846,7 +26823,7 @@ function extractInjectableMetadata(clazz, decorator, reflector) {
     };
   } else if (decorator.args.length === 1) {
     const metaNode = decorator.args[0];
-    if (!import_typescript54.default.isObjectLiteralExpression(metaNode)) {
+    if (!import_typescript53.default.isObjectLiteralExpression(metaNode)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, metaNode, `@Injectable argument must be an object literal`);
     }
     const meta = reflectObjectLiteral(metaNode);
@@ -26854,7 +26831,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_typescript54.default.isArrayLiteralExpression(depsExpr)) {
+      if (!import_typescript53.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));
@@ -26939,12 +26916,12 @@ function getDep(dep, reflector) {
     }
     return true;
   }
-  if (import_typescript54.default.isArrayLiteralExpression(dep)) {
+  if (import_typescript53.default.isArrayLiteralExpression(dep)) {
     dep.elements.forEach((el) => {
       let isDecorator = false;
-      if (import_typescript54.default.isIdentifier(el)) {
+      if (import_typescript53.default.isIdentifier(el)) {
         isDecorator = maybeUpdateDecorator(el, reflector);
-      } else if (import_typescript54.default.isNewExpression(el) && import_typescript54.default.isIdentifier(el.expression)) {
+      } else if (import_typescript53.default.isNewExpression(el) && import_typescript53.default.isIdentifier(el.expression)) {
         const token = el.arguments && el.arguments.length > 0 && el.arguments[0] || void 0;
         isDecorator = maybeUpdateDecorator(el.expression, reflector, token);
       }
@@ -26957,7 +26934,7 @@ function getDep(dep, reflector) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/src/pipe.mjs
-var import_typescript55 = __toESM(require("typescript"), 1);
+var import_typescript54 = __toESM(require("typescript"), 1);
 var PipeSymbol = class extends SemanticSymbol {
   constructor(decl, name) {
     super(decl);
@@ -27013,7 +26990,7 @@ var PipeDecoratorHandler = class {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), "@Pipe must have exactly one argument");
     }
     const meta = unwrapExpression(decorator.args[0]);
-    if (!import_typescript55.default.isObjectLiteralExpression(meta)) {
+    if (!import_typescript54.default.isObjectLiteralExpression(meta)) {
       throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta, "@Pipe must have a literal argument");
     }
     const pipe = reflectObjectLiteral(meta);
@@ -27173,7 +27150,7 @@ var Cycle = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/cycles/src/imports.mjs
-var import_typescript56 = __toESM(require("typescript"), 1);
+var import_typescript55 = __toESM(require("typescript"), 1);
 var ImportGraph = class {
   constructor(checker, perf) {
     this.checker = checker;
@@ -27217,10 +27194,10 @@ var ImportGraph = class {
     return this.perf.inPhase(PerfPhase.CycleDetection, () => {
       const imports = /* @__PURE__ */ new Set();
       for (const stmt of sf.statements) {
-        if (!import_typescript56.default.isImportDeclaration(stmt) && !import_typescript56.default.isExportDeclaration(stmt) || stmt.moduleSpecifier === void 0) {
+        if (!import_typescript55.default.isImportDeclaration(stmt) && !import_typescript55.default.isExportDeclaration(stmt) || stmt.moduleSpecifier === void 0) {
           continue;
         }
-        if (import_typescript56.default.isImportDeclaration(stmt) && stmt.importClause !== void 0 && isTypeOnlyImportClause(stmt.importClause)) {
+        if (import_typescript55.default.isImportDeclaration(stmt) && stmt.importClause !== void 0 && isTypeOnlyImportClause(stmt.importClause)) {
           continue;
         }
         const symbol = this.checker.getSymbolAtLocation(stmt.moduleSpecifier);
@@ -27228,7 +27205,7 @@ var ImportGraph = class {
           continue;
         }
         const moduleFile = symbol.valueDeclaration;
-        if (import_typescript56.default.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
+        if (import_typescript55.default.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
           imports.add(moduleFile);
         }
       }
@@ -27243,7 +27220,7 @@ function isTypeOnlyImportClause(node) {
   if (node.isTypeOnly) {
     return true;
   }
-  if (node.namedBindings !== void 0 && import_typescript56.default.isNamedImports(node.namedBindings) && node.namedBindings.elements.every((specifier) => specifier.isTypeOnly)) {
+  if (node.namedBindings !== void 0 && import_typescript55.default.isNamedImports(node.namedBindings) && node.namedBindings.elements.every((specifier) => specifier.isTypeOnly)) {
     return true;
   }
   return false;
@@ -27265,7 +27242,7 @@ var Found = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/entry_point/src/generator.mjs
-var import_typescript57 = __toESM(require("typescript"), 1);
+var import_typescript56 = __toESM(require("typescript"), 1);
 var FlatIndexGenerator = class {
   constructor(entryPoint, relativeFlatIndexPath, moduleName) {
     this.entryPoint = entryPoint;
@@ -27281,7 +27258,7 @@ var FlatIndexGenerator = class {
 
 export * from '${relativeEntryPoint}';
 `;
-    const genFile = import_typescript57.default.createSourceFile(this.flatIndexPath, contents, import_typescript57.default.ScriptTarget.ES2015, true, import_typescript57.default.ScriptKind.TS);
+    const genFile = import_typescript56.default.createSourceFile(this.flatIndexPath, contents, import_typescript56.default.ScriptTarget.ES2015, true, import_typescript56.default.ScriptKind.TS);
     if (this.moduleName !== null) {
       genFile.moduleName = this.moduleName;
     }
@@ -27306,7 +27283,7 @@ function findFlatIndexEntryPoint(rootFiles) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/entry_point/src/private_export_checker.mjs
-var import_typescript59 = __toESM(require("typescript"), 1);
+var import_typescript58 = __toESM(require("typescript"), 1);
 function checkForPrivateExports(entryPoint, checker, refGraph) {
   const diagnostics = [];
   const topLevelExports = /* @__PURE__ */ new Set();
@@ -27316,7 +27293,7 @@ function checkForPrivateExports(entryPoint, checker, refGraph) {
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   exportedSymbols.forEach((symbol) => {
-    if (symbol.flags & import_typescript59.default.SymbolFlags.Alias) {
+    if (symbol.flags & import_typescript58.default.SymbolFlags.Alias) {
       symbol = checker.getAliasedSymbol(symbol);
     }
     const decl = symbol.valueDeclaration;
@@ -27340,7 +27317,7 @@ function checkForPrivateExports(entryPoint, checker, refGraph) {
           visibleVia = transitivePath.map((seg) => getNameOfDeclaration(seg)).join(" -> ");
         }
         const diagnostic = __spreadProps(__spreadValues({
-          category: import_typescript59.default.DiagnosticCategory.Error,
+          category: import_typescript58.default.DiagnosticCategory.Error,
           code: ngErrorCode(ErrorCode.SYMBOL_NOT_EXPORTED),
           file: transitiveReference.getSourceFile()
         }, getPosOfDeclaration(transitiveReference)), {
@@ -27360,7 +27337,7 @@ function getPosOfDeclaration(decl) {
   };
 }
 function getIdentifierOfDeclaration(decl) {
-  if ((import_typescript59.default.isClassDeclaration(decl) || import_typescript59.default.isVariableDeclaration(decl) || import_typescript59.default.isFunctionDeclaration(decl)) && decl.name !== void 0 && import_typescript59.default.isIdentifier(decl.name)) {
+  if ((import_typescript58.default.isClassDeclaration(decl) || import_typescript58.default.isVariableDeclaration(decl) || import_typescript58.default.isFunctionDeclaration(decl)) && decl.name !== void 0 && import_typescript58.default.isIdentifier(decl.name)) {
     return decl.name;
   } else {
     return null;
@@ -27372,13 +27349,13 @@ function getNameOfDeclaration(decl) {
 }
 function getDescriptorOfDeclaration(decl) {
   switch (decl.kind) {
-    case import_typescript59.default.SyntaxKind.ClassDeclaration:
+    case import_typescript58.default.SyntaxKind.ClassDeclaration:
       return "class";
-    case import_typescript59.default.SyntaxKind.FunctionDeclaration:
+    case import_typescript58.default.SyntaxKind.FunctionDeclaration:
       return "function";
-    case import_typescript59.default.SyntaxKind.VariableDeclaration:
+    case import_typescript58.default.SyntaxKind.VariableDeclaration:
       return "variable";
-    case import_typescript59.default.SyntaxKind.EnumDeclaration:
+    case import_typescript58.default.SyntaxKind.EnumDeclaration:
       return "enum";
     default:
       return "declaration";
@@ -27448,10 +27425,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_typescript63 = __toESM(require("typescript"), 1);
+var import_typescript62 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/adapter.mjs
-var import_typescript60 = __toESM(require("typescript"), 1);
+var import_typescript59 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/shims/src/expando.mjs
 var NgExtension = Symbol("NgExtension");
@@ -27582,10 +27559,10 @@ var ShimAdapter = class {
       }
       const prefix = match[1];
       let baseFileName = absoluteFrom(prefix + ".ts");
-      let inputFile = this.delegate.getSourceFile(baseFileName, import_typescript60.default.ScriptTarget.Latest);
+      let inputFile = this.delegate.getSourceFile(baseFileName, import_typescript59.default.ScriptTarget.Latest);
       if (inputFile === void 0) {
         baseFileName = absoluteFrom(prefix + ".tsx");
-        inputFile = this.delegate.getSourceFile(baseFileName, import_typescript60.default.ScriptTarget.Latest);
+        inputFile = this.delegate.getSourceFile(baseFileName, import_typescript59.default.ScriptTarget.Latest);
       }
       if (inputFile === void 0 || isShim(inputFile)) {
         return void 0;
@@ -27673,6 +27650,8 @@ var DelegatingCompilerHost = class {
     this.useCaseSensitiveFileNames = this.delegateMethod("useCaseSensitiveFileNames");
     this.getModuleResolutionCache = this.delegateMethod("getModuleResolutionCache");
     this.hasInvalidatedResolutions = this.delegateMethod("hasInvalidatedResolutions");
+    this.resolveModuleNameLiterals = this.delegateMethod("resolveModuleNameLiterals");
+    this.resolveTypeReferenceDirectiveReferences = this.delegateMethod("resolveTypeReferenceDirectiveReferences");
   }
   delegateMethod(name) {
     return this.delegate[name] !== void 0 ? this.delegate[name].bind(this.delegate) : void 0;
@@ -27738,7 +27717,7 @@ var TsCreateProgramDriver = class {
       this.sfMap.clear();
     }
     for (const [filePath, { newText, originalFile }] of contents.entries()) {
-      const sf = import_typescript63.default.createSourceFile(filePath, newText, import_typescript63.default.ScriptTarget.Latest, true);
+      const sf = import_typescript62.default.createSourceFile(filePath, newText, import_typescript62.default.ScriptTarget.Latest, true);
       if (originalFile !== null) {
         sf[NgOriginalFile] = originalFile;
       }
@@ -27747,7 +27726,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_typescript63.default.createProgram({
+    this.program = import_typescript62.default.createProgram({
       host,
       rootNames: this.program.getRootFileNames(),
       options: this.options,
@@ -28446,7 +28425,7 @@ var NgModuleIndexImpl = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/resource/src/loader.mjs
-var import_typescript66 = __toESM(require("typescript"), 1);
+var import_typescript65 = __toESM(require("typescript"), 1);
 var CSS_PREPROCESSOR_EXT = /(\.scss|\.sass|\.less|\.styl)$/;
 var RESOURCE_MARKER = ".$ngresource$";
 var RESOURCE_MARKER_TS = RESOURCE_MARKER + ".ts";
@@ -28558,7 +28537,7 @@ var AdapterResourceLoader = class {
     return this.adapter.rootDirs.map((rootDir) => join(rootDir, segment));
   }
   getResolvedCandidateLocations(url, fromFile) {
-    const failedLookup = import_typescript66.default.resolveModuleName(url + RESOURCE_MARKER, fromFile, this.options, this.lookupResolutionHost);
+    const failedLookup = import_typescript65.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}`);
     }
@@ -28714,7 +28693,7 @@ var SymbolKind;
 })(SymbolKind || (SymbolKind = {}));
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/diagnostic.mjs
-var import_typescript67 = __toESM(require("typescript"), 1);
+var import_typescript66 = __toESM(require("typescript"), 1);
 function makeTemplateDiagnostic(templateId, mapping, span, category, code, messageText, relatedMessages) {
   var _a;
   if (mapping.type === "direct") {
@@ -28723,7 +28702,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
       relatedInformation = [];
       for (const relatedMessage of relatedMessages) {
         relatedInformation.push({
-          category: import_typescript67.default.DiagnosticCategory.Message,
+          category: import_typescript66.default.DiagnosticCategory.Message,
           code: 0,
           file: relatedMessage.sourceFile,
           start: relatedMessage.start,
@@ -28752,7 +28731,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
     if (relatedMessages !== void 0) {
       for (const relatedMessage of relatedMessages) {
         relatedInformation.push({
-          category: import_typescript67.default.DiagnosticCategory.Message,
+          category: import_typescript66.default.DiagnosticCategory.Message,
           code: 0,
           file: relatedMessage.sourceFile,
           start: relatedMessage.start,
@@ -28782,7 +28761,7 @@ function makeTemplateDiagnostic(templateId, mapping, span, category, code, messa
       };
     }
     relatedInformation.push({
-      category: import_typescript67.default.DiagnosticCategory.Message,
+      category: import_typescript66.default.DiagnosticCategory.Message,
       code: 0,
       file: componentSf,
       start: mapping.node.getStart(),
@@ -28817,7 +28796,7 @@ function parseTemplateAsSourceFile(fileName, template) {
   if (parseTemplateAsSourceFileForTest !== null) {
     return parseTemplateAsSourceFileForTest(fileName, template);
   }
-  return import_typescript67.default.createSourceFile(fileName, template, import_typescript67.default.ScriptTarget.Latest, false, import_typescript67.default.ScriptKind.JSX);
+  return import_typescript66.default.createSourceFile(fileName, template, import_typescript66.default.ScriptTarget.Latest, false, import_typescript66.default.ScriptKind.JSX);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/id.mjs
@@ -28838,14 +28817,14 @@ function allocateTemplateId(sf) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/completion.mjs
-var import_typescript69 = __toESM(require("typescript"), 1);
+var import_typescript68 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/comments.mjs
-var import_typescript68 = __toESM(require("typescript"), 1);
+var import_typescript67 = __toESM(require("typescript"), 1);
 var parseSpanComment = /^(\d+),(\d+)$/;
 function readSpanComment(node, sourceFile = node.getSourceFile()) {
-  return import_typescript68.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== import_typescript68.default.SyntaxKind.MultiLineCommentTrivia) {
+  return import_typescript67.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== import_typescript67.default.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -28868,25 +28847,25 @@ var ExpressionIdentifier;
   ExpressionIdentifier2["EVENT_PARAMETER"] = "EP";
 })(ExpressionIdentifier || (ExpressionIdentifier = {}));
 function addExpressionIdentifier(node, identifier) {
-  import_typescript68.default.addSyntheticTrailingComment(
+  import_typescript67.default.addSyntheticTrailingComment(
     node,
-    import_typescript68.default.SyntaxKind.MultiLineCommentTrivia,
+    import_typescript67.default.SyntaxKind.MultiLineCommentTrivia,
     `${CommentTriviaType.EXPRESSION_TYPE_IDENTIFIER}:${identifier}`,
     false
   );
 }
 var IGNORE_FOR_DIAGNOSTICS_MARKER = `${CommentTriviaType.DIAGNOSTIC}:ignore`;
 function markIgnoreDiagnostics(node) {
-  import_typescript68.default.addSyntheticTrailingComment(
+  import_typescript67.default.addSyntheticTrailingComment(
     node,
-    import_typescript68.default.SyntaxKind.MultiLineCommentTrivia,
+    import_typescript67.default.SyntaxKind.MultiLineCommentTrivia,
     IGNORE_FOR_DIAGNOSTICS_MARKER,
     false
   );
 }
 function hasIgnoreForDiagnosticsMarker(node, sourceFile) {
-  return import_typescript68.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== import_typescript68.default.SyntaxKind.MultiLineCommentTrivia) {
+  return import_typescript67.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== import_typescript67.default.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -28960,8 +28939,8 @@ function findAllMatchingNodes(tcb, opts) {
   return results;
 }
 function hasExpressionIdentifier(sourceFile, node, identifier) {
-  return import_typescript68.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
-    if (kind !== import_typescript68.default.SyntaxKind.MultiLineCommentTrivia) {
+  return import_typescript67.default.forEachTrailingCommentRange(sourceFile.text, node.getEnd(), (pos, end, kind) => {
+    if (kind !== import_typescript67.default.SyntaxKind.MultiLineCommentTrivia) {
       return false;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -28979,7 +28958,7 @@ var CompletionEngine = class {
     this.templateContextCache = /* @__PURE__ */ new Map();
     this.expressionCompletionCache = /* @__PURE__ */ new Map();
     const globalRead = findFirstMatchingNode(this.tcb, {
-      filter: import_typescript69.default.isPropertyAccessExpression,
+      filter: import_typescript68.default.isPropertyAccessExpression,
       withExpressionIdentifier: ExpressionIdentifier.COMPONENT_COMPLETION
     });
     if (globalRead !== null) {
@@ -29003,7 +28982,7 @@ var CompletionEngine = class {
     let nodeContext = null;
     if (node instanceof EmptyExpr) {
       const nodeLocation = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript69.default.isIdentifier,
+        filter: import_typescript68.default.isIdentifier,
         withSpan: node.sourceSpan
       });
       if (nodeLocation !== null) {
@@ -29016,7 +28995,7 @@ var CompletionEngine = class {
     }
     if (node instanceof PropertyRead && node.receiver instanceof ImplicitReceiver) {
       const nodeLocation = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript69.default.isPropertyAccessExpression,
+        filter: import_typescript68.default.isPropertyAccessExpression,
         withSpan: node.sourceSpan
       });
       if (nodeLocation) {
@@ -29040,21 +29019,21 @@ var CompletionEngine = class {
     let tsExpr = null;
     if (expr instanceof PropertyRead || expr instanceof PropertyWrite) {
       tsExpr = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript69.default.isPropertyAccessExpression,
+        filter: import_typescript68.default.isPropertyAccessExpression,
         withSpan: expr.nameSpan
       });
     } else if (expr instanceof SafePropertyRead) {
       const ternaryExpr = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript69.default.isParenthesizedExpression,
+        filter: import_typescript68.default.isParenthesizedExpression,
         withSpan: expr.sourceSpan
       });
-      if (ternaryExpr === null || !import_typescript69.default.isConditionalExpression(ternaryExpr.expression)) {
+      if (ternaryExpr === null || !import_typescript68.default.isConditionalExpression(ternaryExpr.expression)) {
         return null;
       }
       const whenTrue = ternaryExpr.expression.whenTrue;
-      if (import_typescript69.default.isPropertyAccessExpression(whenTrue)) {
+      if (import_typescript68.default.isPropertyAccessExpression(whenTrue)) {
         tsExpr = whenTrue;
-      } else if (import_typescript69.default.isCallExpression(whenTrue) && import_typescript69.default.isPropertyAccessExpression(whenTrue.expression)) {
+      } else if (import_typescript68.default.isCallExpression(whenTrue) && import_typescript68.default.isPropertyAccessExpression(whenTrue.expression)) {
         tsExpr = whenTrue.expression;
       }
     }
@@ -29076,15 +29055,15 @@ var CompletionEngine = class {
     let tsExpr = null;
     if (expr instanceof TextAttribute) {
       const strNode = findFirstMatchingNode(this.tcb, {
-        filter: import_typescript69.default.isParenthesizedExpression,
+        filter: import_typescript68.default.isParenthesizedExpression,
         withSpan: expr.sourceSpan
       });
-      if (strNode !== null && import_typescript69.default.isStringLiteral(strNode.expression)) {
+      if (strNode !== null && import_typescript68.default.isStringLiteral(strNode.expression)) {
         tsExpr = strNode.expression;
       }
     } else {
       tsExpr = findFirstMatchingNode(this.tcb, {
-        filter: (n) => import_typescript69.default.isStringLiteral(n) || import_typescript69.default.isNumericLiteral(n),
+        filter: (n) => import_typescript68.default.isStringLiteral(n) || import_typescript68.default.isNumericLiteral(n),
         withSpan: expr.sourceSpan
       });
     }
@@ -29092,7 +29071,7 @@ var CompletionEngine = class {
       return null;
     }
     let positionInShimFile = tsExpr.getEnd();
-    if (import_typescript69.default.isStringLiteral(tsExpr)) {
+    if (import_typescript68.default.isStringLiteral(tsExpr)) {
       positionInShimFile -= 1;
     }
     const res = {
@@ -29127,10 +29106,10 @@ var CompletionEngine = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/context.mjs
-var import_typescript84 = __toESM(require("typescript"), 1);
+var import_typescript83 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/dom.mjs
-var import_typescript70 = __toESM(require("typescript"), 1);
+var import_typescript69 = __toESM(require("typescript"), 1);
 var REGISTRY = new DomElementSchemaRegistry();
 var REMOVE_XHTML_REGEX = /^:xhtml:/;
 var RegistryDomSchemaChecker = class {
@@ -29155,7 +29134,7 @@ var RegistryDomSchemaChecker = class {
       } else {
         errorMsg += `2. To allow any element add 'NO_ERRORS_SCHEMA' to the ${schemas2} of this component.`;
       }
-      const diag = makeTemplateDiagnostic(id, mapping, element.startSourceSpan, import_typescript70.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ELEMENT), errorMsg);
+      const diag = makeTemplateDiagnostic(id, mapping, element.startSourceSpan, import_typescript69.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ELEMENT), errorMsg);
       this._diagnostics.push(diag);
     }
   }
@@ -29175,100 +29154,100 @@ var RegistryDomSchemaChecker = class {
 2. If '${element.name}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the ${schemas2} of this component to suppress this message.
 3. To allow any property add 'NO_ERRORS_SCHEMA' to the ${schemas2} of this component.`;
       }
-      const diag = makeTemplateDiagnostic(id, mapping, span, import_typescript70.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ATTRIBUTE), errorMsg);
+      const diag = makeTemplateDiagnostic(id, mapping, span, import_typescript69.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SCHEMA_INVALID_ATTRIBUTE), errorMsg);
       this._diagnostics.push(diag);
     }
   }
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/environment.mjs
-var import_typescript77 = __toESM(require("typescript"), 1);
+var import_typescript76 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/ts_util.mjs
-var import_typescript71 = __toESM(require("typescript"), 1);
+var import_typescript70 = __toESM(require("typescript"), 1);
 var SAFE_TO_CAST_WITHOUT_PARENS = /* @__PURE__ */ new Set([
-  import_typescript71.default.SyntaxKind.ParenthesizedExpression,
-  import_typescript71.default.SyntaxKind.Identifier,
-  import_typescript71.default.SyntaxKind.CallExpression,
-  import_typescript71.default.SyntaxKind.NonNullExpression,
-  import_typescript71.default.SyntaxKind.ElementAccessExpression,
-  import_typescript71.default.SyntaxKind.PropertyAccessExpression,
-  import_typescript71.default.SyntaxKind.ArrayLiteralExpression,
-  import_typescript71.default.SyntaxKind.ObjectLiteralExpression,
-  import_typescript71.default.SyntaxKind.StringLiteral,
-  import_typescript71.default.SyntaxKind.NumericLiteral,
-  import_typescript71.default.SyntaxKind.TrueKeyword,
-  import_typescript71.default.SyntaxKind.FalseKeyword,
-  import_typescript71.default.SyntaxKind.NullKeyword,
-  import_typescript71.default.SyntaxKind.UndefinedKeyword
+  import_typescript70.default.SyntaxKind.ParenthesizedExpression,
+  import_typescript70.default.SyntaxKind.Identifier,
+  import_typescript70.default.SyntaxKind.CallExpression,
+  import_typescript70.default.SyntaxKind.NonNullExpression,
+  import_typescript70.default.SyntaxKind.ElementAccessExpression,
+  import_typescript70.default.SyntaxKind.PropertyAccessExpression,
+  import_typescript70.default.SyntaxKind.ArrayLiteralExpression,
+  import_typescript70.default.SyntaxKind.ObjectLiteralExpression,
+  import_typescript70.default.SyntaxKind.StringLiteral,
+  import_typescript70.default.SyntaxKind.NumericLiteral,
+  import_typescript70.default.SyntaxKind.TrueKeyword,
+  import_typescript70.default.SyntaxKind.FalseKeyword,
+  import_typescript70.default.SyntaxKind.NullKeyword,
+  import_typescript70.default.SyntaxKind.UndefinedKeyword
 ]);
 function tsCastToAny(expr) {
   if (!SAFE_TO_CAST_WITHOUT_PARENS.has(expr.kind)) {
-    expr = import_typescript71.default.factory.createParenthesizedExpression(expr);
+    expr = import_typescript70.default.factory.createParenthesizedExpression(expr);
   }
-  return import_typescript71.default.factory.createParenthesizedExpression(import_typescript71.default.factory.createAsExpression(expr, import_typescript71.default.factory.createKeywordTypeNode(import_typescript71.default.SyntaxKind.AnyKeyword)));
+  return import_typescript70.default.factory.createParenthesizedExpression(import_typescript70.default.factory.createAsExpression(expr, import_typescript70.default.factory.createKeywordTypeNode(import_typescript70.default.SyntaxKind.AnyKeyword)));
 }
 function tsCreateElement(tagName) {
-  const createElement = import_typescript71.default.factory.createPropertyAccessExpression(
-    import_typescript71.default.factory.createIdentifier("document"),
+  const createElement = import_typescript70.default.factory.createPropertyAccessExpression(
+    import_typescript70.default.factory.createIdentifier("document"),
     "createElement"
   );
-  return import_typescript71.default.factory.createCallExpression(
+  return import_typescript70.default.factory.createCallExpression(
     createElement,
     void 0,
-    [import_typescript71.default.factory.createStringLiteral(tagName)]
+    [import_typescript70.default.factory.createStringLiteral(tagName)]
   );
 }
 function tsDeclareVariable(id, type) {
-  const decl = import_typescript71.default.factory.createVariableDeclaration(
+  const decl = import_typescript70.default.factory.createVariableDeclaration(
     id,
     void 0,
     type,
-    import_typescript71.default.factory.createNonNullExpression(import_typescript71.default.factory.createNull())
+    import_typescript70.default.factory.createNonNullExpression(import_typescript70.default.factory.createNull())
   );
-  return import_typescript71.default.factory.createVariableStatement(
+  return import_typescript70.default.factory.createVariableStatement(
     void 0,
     [decl]
   );
 }
 function tsCreateTypeQueryForCoercedInput(typeName, coercedInputName) {
-  return import_typescript71.default.factory.createTypeQueryNode(import_typescript71.default.factory.createQualifiedName(typeName, `ngAcceptInputType_${coercedInputName}`));
+  return import_typescript70.default.factory.createTypeQueryNode(import_typescript70.default.factory.createQualifiedName(typeName, `ngAcceptInputType_${coercedInputName}`));
 }
 function tsCreateVariable(id, initializer) {
-  const decl = import_typescript71.default.factory.createVariableDeclaration(
+  const decl = import_typescript70.default.factory.createVariableDeclaration(
     id,
     void 0,
     void 0,
     initializer
   );
-  return import_typescript71.default.factory.createVariableStatement(
+  return import_typescript70.default.factory.createVariableStatement(
     void 0,
     [decl]
   );
 }
 function tsCallMethod(receiver, methodName, args = []) {
-  const methodAccess = import_typescript71.default.factory.createPropertyAccessExpression(receiver, methodName);
-  return import_typescript71.default.factory.createCallExpression(
+  const methodAccess = import_typescript70.default.factory.createPropertyAccessExpression(receiver, methodName);
+  return import_typescript70.default.factory.createCallExpression(
     methodAccess,
     void 0,
     args
   );
 }
 function isAccessExpression(node) {
-  return import_typescript71.default.isPropertyAccessExpression(node) || import_typescript71.default.isElementAccessExpression(node);
+  return import_typescript70.default.isPropertyAccessExpression(node) || import_typescript70.default.isElementAccessExpression(node);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.mjs
-var import_typescript76 = __toESM(require("typescript"), 1);
+var import_typescript75 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.mjs
-var import_typescript74 = __toESM(require("typescript"), 1);
+var import_typescript73 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.mjs
-var import_typescript73 = __toESM(require("typescript"), 1);
+var import_typescript72 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_emitter.mjs
-var import_typescript72 = __toESM(require("typescript"), 1);
+var import_typescript71 = __toESM(require("typescript"), 1);
 var INELIGIBLE = {};
 function canEmitType(type, canEmit) {
   return canEmitTypeWorker(type);
@@ -29276,13 +29255,13 @@ function canEmitType(type, canEmit) {
     return visitNode(type2) !== INELIGIBLE;
   }
   function visitNode(node) {
-    if (import_typescript72.default.isImportTypeNode(node)) {
+    if (import_typescript71.default.isImportTypeNode(node)) {
       return INELIGIBLE;
     }
-    if (import_typescript72.default.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
+    if (import_typescript71.default.isTypeReferenceNode(node) && !canEmitTypeReference(node)) {
       return INELIGIBLE;
     } else {
-      return import_typescript72.default.forEachChild(node, visitNode);
+      return import_typescript71.default.forEachChild(node, visitNode);
     }
   }
   function canEmitTypeReference(type2) {
@@ -29299,35 +29278,35 @@ var TypeEmitter = class {
   emitType(type) {
     const typeReferenceTransformer = (context) => {
       const visitNode = (node) => {
-        if (import_typescript72.default.isImportTypeNode(node)) {
+        if (import_typescript71.default.isImportTypeNode(node)) {
           throw new Error("Unable to emit import type");
         }
-        if (import_typescript72.default.isTypeReferenceNode(node)) {
+        if (import_typescript71.default.isTypeReferenceNode(node)) {
           return this.emitTypeReference(node);
-        } else if (import_typescript72.default.isLiteralExpression(node)) {
+        } else if (import_typescript71.default.isLiteralExpression(node)) {
           let clone;
-          if (import_typescript72.default.isStringLiteral(node)) {
-            clone = import_typescript72.default.factory.createStringLiteral(node.text);
-          } else if (import_typescript72.default.isNumericLiteral(node)) {
-            clone = import_typescript72.default.factory.createNumericLiteral(node.text);
-          } else if (import_typescript72.default.isBigIntLiteral(node)) {
-            clone = import_typescript72.default.factory.createBigIntLiteral(node.text);
-          } else if (import_typescript72.default.isNoSubstitutionTemplateLiteral(node)) {
-            clone = import_typescript72.default.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
-          } else if (import_typescript72.default.isRegularExpressionLiteral(node)) {
-            clone = import_typescript72.default.factory.createRegularExpressionLiteral(node.text);
+          if (import_typescript71.default.isStringLiteral(node)) {
+            clone = import_typescript71.default.factory.createStringLiteral(node.text);
+          } else if (import_typescript71.default.isNumericLiteral(node)) {
+            clone = import_typescript71.default.factory.createNumericLiteral(node.text);
+          } else if (import_typescript71.default.isBigIntLiteral(node)) {
+            clone = import_typescript71.default.factory.createBigIntLiteral(node.text);
+          } else if (import_typescript71.default.isNoSubstitutionTemplateLiteral(node)) {
+            clone = import_typescript71.default.factory.createNoSubstitutionTemplateLiteral(node.text, node.rawText);
+          } else if (import_typescript71.default.isRegularExpressionLiteral(node)) {
+            clone = import_typescript71.default.factory.createRegularExpressionLiteral(node.text);
           } else {
-            throw new Error(`Unsupported literal kind ${import_typescript72.default.SyntaxKind[node.kind]}`);
+            throw new Error(`Unsupported literal kind ${import_typescript71.default.SyntaxKind[node.kind]}`);
           }
-          import_typescript72.default.setTextRange(clone, { pos: -1, end: -1 });
+          import_typescript71.default.setTextRange(clone, { pos: -1, end: -1 });
           return clone;
         } else {
-          return import_typescript72.default.visitEachChild(node, visitNode, context);
+          return import_typescript71.default.visitEachChild(node, visitNode, context);
         }
       };
-      return (node) => import_typescript72.default.visitNode(node, visitNode);
+      return (node) => import_typescript71.default.visitNode(node, visitNode, import_typescript71.default.isTypeNode);
     };
-    return import_typescript72.default.transform(type, [typeReferenceTransformer]).transformed[0];
+    return import_typescript71.default.transform(type, [typeReferenceTransformer]).transformed[0];
   }
   emitTypeReference(type) {
     const translatedType = this.translator(type);
@@ -29336,9 +29315,9 @@ var TypeEmitter = class {
     }
     let typeArguments = void 0;
     if (type.typeArguments !== void 0) {
-      typeArguments = import_typescript72.default.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
+      typeArguments = import_typescript71.default.factory.createNodeArray(type.typeArguments.map((typeArg) => this.emitType(typeArg)));
     }
-    return import_typescript72.default.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
+    return import_typescript71.default.factory.updateTypeReferenceNode(type, translatedType.typeName, typeArguments);
   }
 };
 
@@ -29379,11 +29358,11 @@ var TypeParameterEmitter = class {
     return this.typeParameters.map((typeParam) => {
       const constraint = typeParam.constraint !== void 0 ? emitter.emitType(typeParam.constraint) : void 0;
       const defaultType = typeParam.default !== void 0 ? emitter.emitType(typeParam.default) : void 0;
-      return import_typescript73.default.factory.updateTypeParameterDeclaration(typeParam, typeParam.modifiers, typeParam.name, constraint, defaultType);
+      return import_typescript72.default.factory.updateTypeParameterDeclaration(typeParam, typeParam.modifiers, typeParam.name, constraint, defaultType);
     });
   }
   resolveTypeReference(type) {
-    const target = import_typescript73.default.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
+    const target = import_typescript72.default.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
     const declaration = this.reflector.getDeclarationOfIdentifier(target);
     if (declaration === null || declaration.node === null) {
       return null;
@@ -29409,8 +29388,8 @@ var TypeParameterEmitter = class {
     if (typeNode === null) {
       return null;
     }
-    if (!import_typescript73.default.isTypeReferenceNode(typeNode)) {
-      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${import_typescript73.default.SyntaxKind[typeNode.kind]}.`);
+    if (!import_typescript72.default.isTypeReferenceNode(typeNode)) {
+      throw new Error(`Expected TypeReferenceNode for emitted reference, got ${import_typescript72.default.SyntaxKind[typeNode.kind]}.`);
     }
     return typeNode;
   }
@@ -29452,14 +29431,14 @@ function getTemplateMapping(shimSf, position, resolver, isDiagnosticRequest) {
 }
 function findTypeCheckBlock(file, id, isDiagnosticRequest) {
   for (const stmt of file.statements) {
-    if (import_typescript74.default.isFunctionDeclaration(stmt) && getTemplateId2(stmt, file, isDiagnosticRequest) === id) {
+    if (import_typescript73.default.isFunctionDeclaration(stmt) && getTemplateId2(stmt, file, isDiagnosticRequest) === id) {
       return stmt;
     }
   }
   return null;
 }
 function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
-  while (node !== void 0 && !import_typescript74.default.isFunctionDeclaration(node)) {
+  while (node !== void 0 && !import_typescript73.default.isFunctionDeclaration(node)) {
     if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {
       return null;
     }
@@ -29476,7 +29455,7 @@ function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
   return null;
 }
 function getTemplateId2(node, sourceFile, isDiagnosticRequest) {
-  while (!import_typescript74.default.isFunctionDeclaration(node)) {
+  while (!import_typescript73.default.isFunctionDeclaration(node)) {
     if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {
       return null;
     }
@@ -29486,8 +29465,8 @@ function getTemplateId2(node, sourceFile, isDiagnosticRequest) {
     }
   }
   const start = node.getFullStart();
-  return import_typescript74.default.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
-    if (kind !== import_typescript74.default.SyntaxKind.MultiLineCommentTrivia) {
+  return import_typescript73.default.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
+    if (kind !== import_typescript73.default.SyntaxKind.MultiLineCommentTrivia) {
       return null;
     }
     const commentText = sourceFile.text.substring(pos + 2, end - 2);
@@ -29502,29 +29481,29 @@ function checkIfGenericTypeBoundsCanBeEmitted(node, reflector, env) {
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.mjs
 function generateTypeCtorDeclarationFn(node, meta, nodeTypeRef, typeParams) {
   const rawTypeArgs = typeParams !== void 0 ? generateGenericArgs(typeParams) : void 0;
-  const rawType = import_typescript76.default.factory.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);
+  const rawType = import_typescript75.default.factory.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);
   const initParam = constructTypeCtorParameter(node, meta, rawType);
   const typeParameters = typeParametersWithDefaultTypes(typeParams);
   if (meta.body) {
-    const fnType = import_typescript76.default.factory.createFunctionTypeNode(
+    const fnType = import_typescript75.default.factory.createFunctionTypeNode(
       typeParameters,
       [initParam],
       rawType
     );
-    const decl = import_typescript76.default.factory.createVariableDeclaration(
+    const decl = import_typescript75.default.factory.createVariableDeclaration(
       meta.fnName,
       void 0,
       fnType,
-      import_typescript76.default.factory.createNonNullExpression(import_typescript76.default.factory.createNull())
+      import_typescript75.default.factory.createNonNullExpression(import_typescript75.default.factory.createNull())
     );
-    const declList = import_typescript76.default.factory.createVariableDeclarationList([decl], import_typescript76.default.NodeFlags.Const);
-    return import_typescript76.default.factory.createVariableStatement(
+    const declList = import_typescript75.default.factory.createVariableDeclarationList([decl], import_typescript75.default.NodeFlags.Const);
+    return import_typescript75.default.factory.createVariableStatement(
       void 0,
       declList
     );
   } else {
-    return createFunctionDeclaration(
-      [import_typescript76.default.factory.createModifier(import_typescript76.default.SyntaxKind.DeclareKeyword)],
+    return import_typescript75.default.factory.createFunctionDeclaration(
+      [import_typescript75.default.factory.createModifier(import_typescript75.default.SyntaxKind.DeclareKeyword)],
       void 0,
       meta.fnName,
       typeParameters,
@@ -29536,16 +29515,16 @@ function generateTypeCtorDeclarationFn(node, meta, nodeTypeRef, typeParams) {
 }
 function generateInlineTypeCtor(node, meta) {
   const rawTypeArgs = node.typeParameters !== void 0 ? generateGenericArgs(node.typeParameters) : void 0;
-  const rawType = import_typescript76.default.factory.createTypeReferenceNode(node.name, rawTypeArgs);
+  const rawType = import_typescript75.default.factory.createTypeReferenceNode(node.name, rawTypeArgs);
   const initParam = constructTypeCtorParameter(node, meta, rawType);
   let body = void 0;
   if (meta.body) {
-    body = import_typescript76.default.factory.createBlock([
-      import_typescript76.default.factory.createReturnStatement(import_typescript76.default.factory.createNonNullExpression(import_typescript76.default.factory.createNull()))
+    body = import_typescript75.default.factory.createBlock([
+      import_typescript75.default.factory.createReturnStatement(import_typescript75.default.factory.createNonNullExpression(import_typescript75.default.factory.createNull()))
     ]);
   }
-  return import_typescript76.default.factory.createMethodDeclaration(
-    [import_typescript76.default.factory.createModifier(import_typescript76.default.SyntaxKind.StaticKeyword)],
+  return import_typescript75.default.factory.createMethodDeclaration(
+    [import_typescript75.default.factory.createModifier(import_typescript75.default.SyntaxKind.StaticKeyword)],
     void 0,
     meta.fnName,
     void 0,
@@ -29562,9 +29541,9 @@ function constructTypeCtorParameter(node, meta, rawType) {
   const coercedKeys = [];
   for (const key of keys) {
     if (!meta.coercedInputFields.has(key)) {
-      plainKeys.push(import_typescript76.default.factory.createLiteralTypeNode(import_typescript76.default.factory.createStringLiteral(key)));
+      plainKeys.push(import_typescript75.default.factory.createLiteralTypeNode(import_typescript75.default.factory.createStringLiteral(key)));
     } else {
-      coercedKeys.push(import_typescript76.default.factory.createPropertySignature(
+      coercedKeys.push(import_typescript75.default.factory.createPropertySignature(
         void 0,
         key,
         void 0,
@@ -29573,17 +29552,17 @@ function constructTypeCtorParameter(node, meta, rawType) {
     }
   }
   if (plainKeys.length > 0) {
-    const keyTypeUnion = import_typescript76.default.factory.createUnionTypeNode(plainKeys);
-    initType = import_typescript76.default.factory.createTypeReferenceNode("Pick", [rawType, keyTypeUnion]);
+    const keyTypeUnion = import_typescript75.default.factory.createUnionTypeNode(plainKeys);
+    initType = import_typescript75.default.factory.createTypeReferenceNode("Pick", [rawType, keyTypeUnion]);
   }
   if (coercedKeys.length > 0) {
-    const coercedLiteral = import_typescript76.default.factory.createTypeLiteralNode(coercedKeys);
-    initType = initType !== null ? import_typescript76.default.factory.createIntersectionTypeNode([initType, coercedLiteral]) : coercedLiteral;
+    const coercedLiteral = import_typescript75.default.factory.createTypeLiteralNode(coercedKeys);
+    initType = initType !== null ? import_typescript75.default.factory.createIntersectionTypeNode([initType, coercedLiteral]) : coercedLiteral;
   }
   if (initType === null) {
-    initType = import_typescript76.default.factory.createTypeLiteralNode([]);
+    initType = import_typescript75.default.factory.createTypeLiteralNode([]);
   }
-  return createParameterDeclaration(
+  return import_typescript75.default.factory.createParameterDeclaration(
     void 0,
     void 0,
     "init",
@@ -29593,7 +29572,7 @@ function constructTypeCtorParameter(node, meta, rawType) {
   );
 }
 function generateGenericArgs(params) {
-  return params.map((param) => import_typescript76.default.factory.createTypeReferenceNode(param.name, void 0));
+  return params.map((param) => import_typescript75.default.factory.createTypeReferenceNode(param.name, void 0));
 }
 function requiresInlineTypeCtor(node, host, env) {
   return !checkIfGenericTypeBoundsCanBeEmitted(node, host, env);
@@ -29604,7 +29583,7 @@ function typeParametersWithDefaultTypes(params) {
   }
   return params.map((param) => {
     if (param.default === void 0) {
-      return import_typescript76.default.factory.updateTypeParameterDeclaration(param, param.modifiers, param.name, param.constraint, import_typescript76.default.factory.createKeywordTypeNode(import_typescript76.default.SyntaxKind.AnyKeyword));
+      return import_typescript75.default.factory.updateTypeParameterDeclaration(param, param.modifiers, param.name, param.constraint, import_typescript75.default.factory.createKeywordTypeNode(import_typescript75.default.SyntaxKind.AnyKeyword));
     } else {
       return param;
     }
@@ -29636,13 +29615,13 @@ var Environment = class {
     }
     if (requiresInlineTypeCtor(node, this.reflector, this)) {
       const ref = this.reference(dirRef);
-      const typeCtorExpr = import_typescript77.default.factory.createPropertyAccessExpression(ref, "ngTypeCtor");
+      const typeCtorExpr = import_typescript76.default.factory.createPropertyAccessExpression(ref, "ngTypeCtor");
       this.typeCtors.set(node, typeCtorExpr);
       return typeCtorExpr;
     } else {
       const fnName = `_ctor${this.nextIds.typeCtor++}`;
       const nodeTypeRef = this.referenceType(dirRef);
-      if (!import_typescript77.default.isTypeReferenceNode(nodeTypeRef)) {
+      if (!import_typescript76.default.isTypeReferenceNode(nodeTypeRef)) {
         throw new Error(`Expected TypeReferenceNode from reference to ${dirRef.debugName}`);
       }
       const meta = {
@@ -29658,7 +29637,7 @@ var Environment = class {
       const typeParams = this.emitTypeParameters(node);
       const typeCtor = generateTypeCtorDeclarationFn(node, meta, nodeTypeRef.typeName, typeParams);
       this.typeCtorStatements.push(typeCtor);
-      const fnId = import_typescript77.default.factory.createIdentifier(fnName);
+      const fnId = import_typescript76.default.factory.createIdentifier(fnName);
       this.typeCtors.set(node, fnId);
       return fnId;
     }
@@ -29668,7 +29647,7 @@ var Environment = class {
       return this.pipeInsts.get(ref.node);
     }
     const pipeType = this.referenceType(ref);
-    const pipeInstId = import_typescript77.default.factory.createIdentifier(`_pipe${this.nextIds.pipeInst++}`);
+    const pipeInstId = import_typescript76.default.factory.createIdentifier(`_pipe${this.nextIds.pipeInst++}`);
     this.pipeInstStatements.push(tsDeclareVariable(pipeInstId, pipeType));
     this.pipeInsts.set(ref.node, pipeInstId);
     return pipeInstId;
@@ -29704,7 +29683,7 @@ var Environment = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/oob.mjs
-var import_typescript78 = __toESM(require("typescript"), 1);
+var import_typescript77 = __toESM(require("typescript"), 1);
 var OutOfBandDiagnosticRecorderImpl = class {
   constructor(resolver) {
     this.resolver = resolver;
@@ -29718,7 +29697,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     const mapping = this.resolver.getSourceMapping(templateId);
     const value = ref.value.trim();
     const errorMsg = `No directive found with exportAs '${value}'.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, ref.valueSpan || ref.sourceSpan, import_typescript78.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_REFERENCE_TARGET), errorMsg));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, ref.valueSpan || ref.sourceSpan, import_typescript77.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_REFERENCE_TARGET), errorMsg));
   }
   missingPipe(templateId, ast) {
     if (this.recordedPipes.has(ast)) {
@@ -29730,7 +29709,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     if (sourceSpan === null) {
       throw new Error(`Assertion failure: no SourceLocation found for usage of pipe '${ast.name}'.`);
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, import_typescript78.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_PIPE), errorMsg));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, import_typescript77.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.MISSING_PIPE), errorMsg));
     this.recordedPipes.add(ast);
   }
   illegalAssignmentToTemplateVar(templateId, assignment, target) {
@@ -29741,7 +29720,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     if (sourceSpan === null) {
       throw new Error(`Assertion failure: no SourceLocation found for property binding.`);
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, import_typescript78.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.WRITE_TO_READ_ONLY_VARIABLE), errorMsg, [{
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, sourceSpan, import_typescript77.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.WRITE_TO_READ_ONLY_VARIABLE), errorMsg, [{
       text: `The variable ${assignment.name} is declared here.`,
       start: ((_a = target.valueSpan) == null ? void 0 : _a.start.offset) || target.sourceSpan.start.offset,
       end: ((_b = target.valueSpan) == null ? void 0 : _b.end.offset) || target.sourceSpan.end.offset,
@@ -29751,7 +29730,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
   duplicateTemplateVar(templateId, variable2, firstDecl) {
     const mapping = this.resolver.getSourceMapping(templateId);
     const errorMsg = `Cannot redeclare variable '${variable2.name}' as it was previously declared elsewhere for the same template.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, variable2.sourceSpan, import_typescript78.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DUPLICATE_VARIABLE_DECLARATION), errorMsg, [{
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, variable2.sourceSpan, import_typescript77.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DUPLICATE_VARIABLE_DECLARATION), errorMsg, [{
       text: `The variable '${firstDecl.name}' was first declared here.`,
       start: firstDecl.sourceSpan.start.offset,
       end: firstDecl.sourceSpan.end.offset,
@@ -29790,7 +29769,7 @@ var OutOfBandDiagnosticRecorderImpl = class {
     const message = `This structural directive supports advanced type inference, but the current compiler configuration prevents its usage. The variable ${varIdentification} will have type 'any' as a result.
 
 Consider enabling the 'strictTemplates' option in your tsconfig.json for better type inference within this template.`;
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, diagnosticVar.keySpan, import_typescript78.default.DiagnosticCategory.Suggestion, ngErrorCode(ErrorCode.SUGGEST_SUBOPTIMAL_TYPE_INFERENCE), message));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, diagnosticVar.keySpan, import_typescript77.default.DiagnosticCategory.Suggestion, ngErrorCode(ErrorCode.SUGGEST_SUBOPTIMAL_TYPE_INFERENCE), message));
   }
   splitTwoWayBinding(templateId, input, output, inputConsumer, outputConsumer) {
     const mapping = this.resolver.getSourceMapping(templateId);
@@ -29824,7 +29803,7 @@ Consider enabling the 'strictTemplates' option in your tsconfig.json for better
         sourceFile: outputConsumer.name.getSourceFile()
       });
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, input.keySpan, import_typescript78.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SPLIT_TWO_WAY_BINDING), errorMsg, relatedMessages));
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, mapping, input.keySpan, import_typescript77.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.SPLIT_TWO_WAY_BINDING), errorMsg, relatedMessages));
   }
 };
 function makeInlineDiagnostic(templateId, code, node, messageText, relatedInformation) {
@@ -29835,7 +29814,7 @@ function makeInlineDiagnostic(templateId, code, node, messageText, relatedInform
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/shim.mjs
-var import_typescript79 = __toESM(require("typescript"), 1);
+var import_typescript78 = __toESM(require("typescript"), 1);
 var TypeCheckShimGenerator = class {
   constructor() {
     this.extensionPrefix = "ngtypecheck";
@@ -29845,7 +29824,7 @@ var TypeCheckShimGenerator = class {
     if (priorShimSf !== null) {
       return priorShimSf;
     }
-    return import_typescript79.default.createSourceFile(genFilePath, "export const USED_FOR_NG_TYPE_CHECKING = true;", import_typescript79.default.ScriptTarget.Latest, true, import_typescript79.default.ScriptKind.TS);
+    return import_typescript78.default.createSourceFile(genFilePath, "export const USED_FOR_NG_TYPE_CHECKING = true;", import_typescript78.default.ScriptTarget.Latest, true, import_typescript78.default.ScriptKind.TS);
   }
   static shimFor(fileName) {
     return absoluteFrom(fileName.replace(/\.tsx?$/, ".ngtypecheck.ts"));
@@ -29853,15 +29832,15 @@ var TypeCheckShimGenerator = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_check_block.mjs
-var import_typescript82 = __toESM(require("typescript"), 1);
+var import_typescript81 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/diagnostics.mjs
-var import_typescript80 = __toESM(require("typescript"), 1);
+var import_typescript79 = __toESM(require("typescript"), 1);
 function wrapForDiagnostics(expr) {
-  return import_typescript80.default.factory.createParenthesizedExpression(expr);
+  return import_typescript79.default.factory.createParenthesizedExpression(expr);
 }
 function wrapForTypeChecker(expr) {
-  return import_typescript80.default.factory.createParenthesizedExpression(expr);
+  return import_typescript79.default.factory.createParenthesizedExpression(expr);
 }
 function addParseSpanInfo(node, span) {
   let commentText;
@@ -29870,10 +29849,10 @@ function addParseSpanInfo(node, span) {
   } else {
     commentText = `${span.start.offset},${span.end.offset}`;
   }
-  import_typescript80.default.addSyntheticTrailingComment(node, import_typescript80.default.SyntaxKind.MultiLineCommentTrivia, commentText, false);
+  import_typescript79.default.addSyntheticTrailingComment(node, import_typescript79.default.SyntaxKind.MultiLineCommentTrivia, commentText, false);
 }
 function addTemplateId(tcb, id) {
-  import_typescript80.default.addSyntheticLeadingComment(tcb, import_typescript80.default.SyntaxKind.MultiLineCommentTrivia, id, true);
+  import_typescript79.default.addSyntheticLeadingComment(tcb, import_typescript79.default.SyntaxKind.MultiLineCommentTrivia, id, true);
 }
 function shouldReportDiagnostic(diagnostic) {
   const { code } = diagnostic;
@@ -29901,32 +29880,32 @@ function translateDiagnostic(diagnostic, resolver) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/expression.mjs
-var import_typescript81 = __toESM(require("typescript"), 1);
-var NULL_AS_ANY = import_typescript81.default.factory.createAsExpression(import_typescript81.default.factory.createNull(), import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword));
-var UNDEFINED = import_typescript81.default.factory.createIdentifier("undefined");
+var import_typescript80 = __toESM(require("typescript"), 1);
+var NULL_AS_ANY = import_typescript80.default.factory.createAsExpression(import_typescript80.default.factory.createNull(), import_typescript80.default.factory.createKeywordTypeNode(import_typescript80.default.SyntaxKind.AnyKeyword));
+var UNDEFINED = import_typescript80.default.factory.createIdentifier("undefined");
 var UNARY_OPS = /* @__PURE__ */ new Map([
-  ["+", import_typescript81.default.SyntaxKind.PlusToken],
-  ["-", import_typescript81.default.SyntaxKind.MinusToken]
+  ["+", import_typescript80.default.SyntaxKind.PlusToken],
+  ["-", import_typescript80.default.SyntaxKind.MinusToken]
 ]);
 var BINARY_OPS = /* @__PURE__ */ new Map([
-  ["+", import_typescript81.default.SyntaxKind.PlusToken],
-  ["-", import_typescript81.default.SyntaxKind.MinusToken],
-  ["<", import_typescript81.default.SyntaxKind.LessThanToken],
-  [">", import_typescript81.default.SyntaxKind.GreaterThanToken],
-  ["<=", import_typescript81.default.SyntaxKind.LessThanEqualsToken],
-  [">=", import_typescript81.default.SyntaxKind.GreaterThanEqualsToken],
-  ["==", import_typescript81.default.SyntaxKind.EqualsEqualsToken],
-  ["===", import_typescript81.default.SyntaxKind.EqualsEqualsEqualsToken],
-  ["*", import_typescript81.default.SyntaxKind.AsteriskToken],
-  ["/", import_typescript81.default.SyntaxKind.SlashToken],
-  ["%", import_typescript81.default.SyntaxKind.PercentToken],
-  ["!=", import_typescript81.default.SyntaxKind.ExclamationEqualsToken],
-  ["!==", import_typescript81.default.SyntaxKind.ExclamationEqualsEqualsToken],
-  ["||", import_typescript81.default.SyntaxKind.BarBarToken],
-  ["&&", import_typescript81.default.SyntaxKind.AmpersandAmpersandToken],
-  ["&", import_typescript81.default.SyntaxKind.AmpersandToken],
-  ["|", import_typescript81.default.SyntaxKind.BarToken],
-  ["??", import_typescript81.default.SyntaxKind.QuestionQuestionToken]
+  ["+", import_typescript80.default.SyntaxKind.PlusToken],
+  ["-", import_typescript80.default.SyntaxKind.MinusToken],
+  ["<", import_typescript80.default.SyntaxKind.LessThanToken],
+  [">", import_typescript80.default.SyntaxKind.GreaterThanToken],
+  ["<=", import_typescript80.default.SyntaxKind.LessThanEqualsToken],
+  [">=", import_typescript80.default.SyntaxKind.GreaterThanEqualsToken],
+  ["==", import_typescript80.default.SyntaxKind.EqualsEqualsToken],
+  ["===", import_typescript80.default.SyntaxKind.EqualsEqualsEqualsToken],
+  ["*", import_typescript80.default.SyntaxKind.AsteriskToken],
+  ["/", import_typescript80.default.SyntaxKind.SlashToken],
+  ["%", import_typescript80.default.SyntaxKind.PercentToken],
+  ["!=", import_typescript80.default.SyntaxKind.ExclamationEqualsToken],
+  ["!==", import_typescript80.default.SyntaxKind.ExclamationEqualsEqualsToken],
+  ["||", import_typescript80.default.SyntaxKind.BarBarToken],
+  ["&&", import_typescript80.default.SyntaxKind.AmpersandAmpersandToken],
+  ["&", import_typescript80.default.SyntaxKind.AmpersandToken],
+  ["|", import_typescript80.default.SyntaxKind.BarToken],
+  ["??", import_typescript80.default.SyntaxKind.QuestionQuestionToken]
 ]);
 function astToTypescript(ast, maybeResolve, config) {
   const translator = new AstTranslator(maybeResolve, config);
@@ -29942,7 +29921,7 @@ var AstTranslator = class {
       ast = ast.ast;
     }
     if (ast instanceof EmptyExpr) {
-      const res = import_typescript81.default.factory.createIdentifier("undefined");
+      const res = import_typescript80.default.factory.createIdentifier("undefined");
       addParseSpanInfo(res, ast.sourceSpan);
       return res;
     }
@@ -29958,7 +29937,7 @@ var AstTranslator = class {
     if (op === void 0) {
       throw new Error(`Unsupported Unary.operator: ${ast.operator}`);
     }
-    const node = wrapForDiagnostics(import_typescript81.default.factory.createPrefixUnaryExpression(op, expr));
+    const node = wrapForDiagnostics(import_typescript80.default.factory.createPrefixUnaryExpression(op, expr));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -29969,13 +29948,13 @@ var AstTranslator = class {
     if (op === void 0) {
       throw new Error(`Unsupported Binary.operation: ${ast.operation}`);
     }
-    const node = import_typescript81.default.factory.createBinaryExpression(lhs, op, rhs);
+    const node = import_typescript80.default.factory.createBinaryExpression(lhs, op, rhs);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitChain(ast) {
     const elements = ast.expressions.map((expr) => this.translate(expr));
-    const node = wrapForDiagnostics(import_typescript81.default.factory.createCommaListExpression(elements));
+    const node = wrapForDiagnostics(import_typescript80.default.factory.createCommaListExpression(elements));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -29983,7 +29962,7 @@ var AstTranslator = class {
     const condExpr = this.translate(ast.condition);
     const trueExpr = this.translate(ast.trueExp);
     const falseExpr = wrapForTypeChecker(this.translate(ast.falseExp));
-    const node = import_typescript81.default.factory.createParenthesizedExpression(import_typescript81.default.factory.createConditionalExpression(condExpr, void 0, trueExpr, void 0, falseExpr));
+    const node = import_typescript80.default.factory.createParenthesizedExpression(import_typescript80.default.factory.createConditionalExpression(condExpr, void 0, trueExpr, void 0, falseExpr));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -29994,26 +29973,26 @@ var AstTranslator = class {
     throw new Error("Method not implemented.");
   }
   visitInterpolation(ast) {
-    return ast.expressions.reduce((lhs, ast2) => import_typescript81.default.factory.createBinaryExpression(lhs, import_typescript81.default.SyntaxKind.PlusToken, wrapForTypeChecker(this.translate(ast2))), import_typescript81.default.factory.createStringLiteral(""));
+    return ast.expressions.reduce((lhs, ast2) => import_typescript80.default.factory.createBinaryExpression(lhs, import_typescript80.default.SyntaxKind.PlusToken, wrapForTypeChecker(this.translate(ast2))), import_typescript80.default.factory.createStringLiteral(""));
   }
   visitKeyedRead(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
     const key = this.translate(ast.key);
-    const node = import_typescript81.default.factory.createElementAccessExpression(receiver, key);
+    const node = import_typescript80.default.factory.createElementAccessExpression(receiver, key);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitKeyedWrite(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-    const left = import_typescript81.default.factory.createElementAccessExpression(receiver, this.translate(ast.key));
+    const left = import_typescript80.default.factory.createElementAccessExpression(receiver, this.translate(ast.key));
     const right = wrapForTypeChecker(this.translate(ast.value));
-    const node = wrapForDiagnostics(import_typescript81.default.factory.createBinaryExpression(left, import_typescript81.default.SyntaxKind.EqualsToken, right));
+    const node = wrapForDiagnostics(import_typescript80.default.factory.createBinaryExpression(left, import_typescript80.default.SyntaxKind.EqualsToken, right));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitLiteralArray(ast) {
     const elements = ast.expressions.map((expr) => this.translate(expr));
-    const literal3 = import_typescript81.default.factory.createArrayLiteralExpression(elements);
+    const literal3 = import_typescript80.default.factory.createArrayLiteralExpression(elements);
     const node = this.config.strictLiteralTypes ? literal3 : tsCastToAny(literal3);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
@@ -30021,9 +30000,9 @@ var AstTranslator = class {
   visitLiteralMap(ast) {
     const properties = ast.keys.map(({ key }, idx) => {
       const value = this.translate(ast.values[idx]);
-      return import_typescript81.default.factory.createPropertyAssignment(import_typescript81.default.factory.createStringLiteral(key), value);
+      return import_typescript80.default.factory.createPropertyAssignment(import_typescript80.default.factory.createStringLiteral(key), value);
     });
-    const literal3 = import_typescript81.default.factory.createObjectLiteralExpression(properties, true);
+    const literal3 = import_typescript80.default.factory.createObjectLiteralExpression(properties, true);
     const node = this.config.strictLiteralTypes ? literal3 : tsCastToAny(literal3);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
@@ -30031,15 +30010,15 @@ var AstTranslator = class {
   visitLiteralPrimitive(ast) {
     let node;
     if (ast.value === void 0) {
-      node = import_typescript81.default.factory.createIdentifier("undefined");
+      node = import_typescript80.default.factory.createIdentifier("undefined");
     } else if (ast.value === null) {
-      node = import_typescript81.default.factory.createNull();
+      node = import_typescript80.default.factory.createNull();
     } else if (typeof ast.value === "string") {
-      node = import_typescript81.default.factory.createStringLiteral(ast.value);
+      node = import_typescript80.default.factory.createStringLiteral(ast.value);
     } else if (typeof ast.value === "number") {
-      node = import_typescript81.default.factory.createNumericLiteral(ast.value);
+      node = import_typescript80.default.factory.createNumericLiteral(ast.value);
     } else if (typeof ast.value === "boolean") {
-      node = ast.value ? import_typescript81.default.factory.createTrue() : import_typescript81.default.factory.createFalse();
+      node = ast.value ? import_typescript80.default.factory.createTrue() : import_typescript80.default.factory.createFalse();
     } else {
       throw Error(`Unsupported AST value of type ${typeof ast.value}`);
     }
@@ -30048,7 +30027,7 @@ var AstTranslator = class {
   }
   visitNonNullAssert(ast) {
     const expr = wrapForDiagnostics(this.translate(ast.expression));
-    const node = import_typescript81.default.factory.createNonNullExpression(expr);
+    const node = import_typescript80.default.factory.createNonNullExpression(expr);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -30057,13 +30036,13 @@ var AstTranslator = class {
   }
   visitPrefixNot(ast) {
     const expression = wrapForDiagnostics(this.translate(ast.expression));
-    const node = import_typescript81.default.factory.createLogicalNot(expression);
+    const node = import_typescript80.default.factory.createLogicalNot(expression);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
   visitPropertyRead(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-    const name = import_typescript81.default.factory.createPropertyAccessExpression(receiver, ast.name);
+    const name = import_typescript80.default.factory.createPropertyAccessExpression(receiver, ast.name);
     addParseSpanInfo(name, ast.nameSpan);
     const node = wrapForDiagnostics(name);
     addParseSpanInfo(node, ast.sourceSpan);
@@ -30071,12 +30050,12 @@ var AstTranslator = class {
   }
   visitPropertyWrite(ast) {
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-    const left = import_typescript81.default.factory.createPropertyAccessExpression(receiver, ast.name);
+    const left = import_typescript80.default.factory.createPropertyAccessExpression(receiver, ast.name);
     addParseSpanInfo(left, ast.nameSpan);
     const leftWithPath = wrapForDiagnostics(left);
     addParseSpanInfo(leftWithPath, ast.sourceSpan);
     const right = wrapForTypeChecker(this.translate(ast.value));
-    const node = wrapForDiagnostics(import_typescript81.default.factory.createBinaryExpression(leftWithPath, import_typescript81.default.SyntaxKind.EqualsToken, right));
+    const node = wrapForDiagnostics(import_typescript80.default.factory.createBinaryExpression(leftWithPath, import_typescript80.default.SyntaxKind.EqualsToken, right));
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -30084,13 +30063,13 @@ var AstTranslator = class {
     let node;
     const receiver = wrapForDiagnostics(this.translate(ast.receiver));
     if (this.config.strictSafeNavigationTypes) {
-      const expr = import_typescript81.default.factory.createPropertyAccessExpression(import_typescript81.default.factory.createNonNullExpression(receiver), ast.name);
+      const expr = import_typescript80.default.factory.createPropertyAccessExpression(import_typescript80.default.factory.createNonNullExpression(receiver), ast.name);
       addParseSpanInfo(expr, ast.nameSpan);
-      node = import_typescript81.default.factory.createParenthesizedExpression(import_typescript81.default.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
+      node = import_typescript80.default.factory.createParenthesizedExpression(import_typescript80.default.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
     } else if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
-      node = import_typescript81.default.factory.createPropertyAccessExpression(tsCastToAny(receiver), ast.name);
+      node = import_typescript80.default.factory.createPropertyAccessExpression(tsCastToAny(receiver), ast.name);
     } else {
-      const expr = import_typescript81.default.factory.createPropertyAccessExpression(import_typescript81.default.factory.createNonNullExpression(receiver), ast.name);
+      const expr = import_typescript80.default.factory.createPropertyAccessExpression(import_typescript80.default.factory.createNonNullExpression(receiver), ast.name);
       addParseSpanInfo(expr, ast.nameSpan);
       node = tsCastToAny(expr);
     }
@@ -30102,13 +30081,13 @@ var AstTranslator = class {
     const key = this.translate(ast.key);
     let node;
     if (this.config.strictSafeNavigationTypes) {
-      const expr = import_typescript81.default.factory.createElementAccessExpression(import_typescript81.default.factory.createNonNullExpression(receiver), key);
+      const expr = import_typescript80.default.factory.createElementAccessExpression(import_typescript80.default.factory.createNonNullExpression(receiver), key);
       addParseSpanInfo(expr, ast.sourceSpan);
-      node = import_typescript81.default.factory.createParenthesizedExpression(import_typescript81.default.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
+      node = import_typescript80.default.factory.createParenthesizedExpression(import_typescript80.default.factory.createConditionalExpression(NULL_AS_ANY, void 0, expr, void 0, UNDEFINED));
     } else if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
-      node = import_typescript81.default.factory.createElementAccessExpression(tsCastToAny(receiver), key);
+      node = import_typescript80.default.factory.createElementAccessExpression(tsCastToAny(receiver), key);
     } else {
-      const expr = import_typescript81.default.factory.createElementAccessExpression(import_typescript81.default.factory.createNonNullExpression(receiver), key);
+      const expr = import_typescript80.default.factory.createElementAccessExpression(import_typescript80.default.factory.createNonNullExpression(receiver), key);
       addParseSpanInfo(expr, ast.sourceSpan);
       node = tsCastToAny(expr);
     }
@@ -30125,7 +30104,7 @@ var AstTranslator = class {
         expr = resolved;
       } else {
         const propertyReceiver = wrapForDiagnostics(this.translate(receiver.receiver));
-        expr = import_typescript81.default.factory.createPropertyAccessExpression(propertyReceiver, receiver.name);
+        expr = import_typescript80.default.factory.createPropertyAccessExpression(propertyReceiver, receiver.name);
         addParseSpanInfo(expr, receiver.nameSpan);
       }
     } else {
@@ -30135,7 +30114,7 @@ var AstTranslator = class {
     if (ast.receiver instanceof SafePropertyRead || ast.receiver instanceof SafeKeyedRead) {
       node = this.convertToSafeCall(ast, expr, args);
     } else {
-      node = import_typescript81.default.factory.createCallExpression(expr, void 0, args);
+      node = import_typescript80.default.factory.createCallExpression(expr, void 0, args);
     }
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
@@ -30149,13 +30128,13 @@ var AstTranslator = class {
   }
   convertToSafeCall(ast, expr, args) {
     if (this.config.strictSafeNavigationTypes) {
-      const call = import_typescript81.default.factory.createCallExpression(import_typescript81.default.factory.createNonNullExpression(expr), void 0, args);
-      return import_typescript81.default.factory.createParenthesizedExpression(import_typescript81.default.factory.createConditionalExpression(NULL_AS_ANY, void 0, call, void 0, UNDEFINED));
+      const call = import_typescript80.default.factory.createCallExpression(import_typescript80.default.factory.createNonNullExpression(expr), void 0, args);
+      return import_typescript80.default.factory.createParenthesizedExpression(import_typescript80.default.factory.createConditionalExpression(NULL_AS_ANY, void 0, call, void 0, UNDEFINED));
     }
     if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
-      return import_typescript81.default.factory.createCallExpression(tsCastToAny(expr), void 0, args);
+      return import_typescript80.default.factory.createCallExpression(tsCastToAny(expr), void 0, args);
     }
-    return tsCastToAny(import_typescript81.default.factory.createCallExpression(import_typescript81.default.factory.createNonNullExpression(expr), void 0, args));
+    return tsCastToAny(import_typescript80.default.factory.createCallExpression(import_typescript80.default.factory.createNonNullExpression(expr), void 0, args));
   }
 };
 var VeSafeLhsInferenceBugDetector = class {
@@ -30263,7 +30242,7 @@ function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecor
   const tcb = new Context2(env, domSchemaChecker, oobRecorder, meta.id, meta.boundTarget, meta.pipes, meta.schemas, meta.isStandalone);
   const scope = Scope2.forNodes(tcb, null, tcb.boundTarget.target.template, null);
   const ctxRawType = env.referenceType(ref);
-  if (!import_typescript82.default.isTypeReferenceNode(ctxRawType)) {
+  if (!import_typescript81.default.isTypeReferenceNode(ctxRawType)) {
     throw new Error(`Expected TypeReferenceNode when referencing the ctx param for ${ref.debugName}`);
   }
   let typeParameters = void 0;
@@ -30275,25 +30254,25 @@ function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecor
     switch (genericContextBehavior) {
       case TcbGenericContextBehavior.UseEmitter:
         typeParameters = new TypeParameterEmitter(ref.node.typeParameters, env.reflector).emit((typeRef) => env.referenceType(typeRef));
-        typeArguments = typeParameters.map((param) => import_typescript82.default.factory.createTypeReferenceNode(param.name));
+        typeArguments = typeParameters.map((param) => import_typescript81.default.factory.createTypeReferenceNode(param.name));
         break;
       case TcbGenericContextBehavior.CopyClassNodes:
         typeParameters = [...ref.node.typeParameters];
-        typeArguments = typeParameters.map((param) => import_typescript82.default.factory.createTypeReferenceNode(param.name));
+        typeArguments = typeParameters.map((param) => import_typescript81.default.factory.createTypeReferenceNode(param.name));
         break;
       case TcbGenericContextBehavior.FallbackToAny:
-        typeArguments = ref.node.typeParameters.map(() => import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword));
+        typeArguments = ref.node.typeParameters.map(() => import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword));
         break;
     }
   }
   const paramList = [tcbThisParam(ctxRawType.typeName, typeArguments)];
   const scopeStatements = scope.render();
-  const innerBody = import_typescript82.default.factory.createBlock([
+  const innerBody = import_typescript81.default.factory.createBlock([
     ...env.getPreludeStatements(),
     ...scopeStatements
   ]);
-  const body = import_typescript82.default.factory.createBlock([import_typescript82.default.factory.createIfStatement(import_typescript82.default.factory.createTrue(), innerBody, void 0)]);
-  const fnDecl = createFunctionDeclaration(
+  const body = import_typescript81.default.factory.createBlock([import_typescript81.default.factory.createIfStatement(import_typescript81.default.factory.createTrue(), innerBody, void 0)]);
+  const fnDecl = import_typescript81.default.factory.createFunctionDeclaration(
     void 0,
     void 0,
     name,
@@ -30342,7 +30321,7 @@ var TcbVariableOp = class extends TcbOp {
   execute() {
     const ctx = this.scope.resolve(this.template);
     const id = this.tcb.allocateId();
-    const initializer = import_typescript82.default.factory.createPropertyAccessExpression(
+    const initializer = import_typescript81.default.factory.createPropertyAccessExpression(
       ctx,
       this.variable.value || "$implicit"
     );
@@ -30368,7 +30347,7 @@ var TcbTemplateContextOp = class extends TcbOp {
   }
   execute() {
     const ctx = this.tcb.allocateId();
-    const type = import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword);
+    const type = import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword);
     this.scope.addStatement(tsDeclareVariable(ctx, type));
     return ctx;
   }
@@ -30421,16 +30400,16 @@ var TcbTemplateBodyOp = class extends TcbOp {
     }
     let guard = null;
     if (directiveGuards.length > 0) {
-      guard = directiveGuards.reduce((expr, dirGuard) => import_typescript82.default.factory.createBinaryExpression(expr, import_typescript82.default.SyntaxKind.AmpersandAmpersandToken, dirGuard), directiveGuards.pop());
+      guard = directiveGuards.reduce((expr, dirGuard) => import_typescript81.default.factory.createBinaryExpression(expr, import_typescript81.default.SyntaxKind.AmpersandAmpersandToken, dirGuard), directiveGuards.pop());
     }
     const tmplScope = Scope2.forNodes(this.tcb, this.scope, this.template, guard);
     const statements = tmplScope.render();
     if (statements.length === 0) {
       return null;
     }
-    let tmplBlock = import_typescript82.default.factory.createBlock(statements);
+    let tmplBlock = import_typescript81.default.factory.createBlock(statements);
     if (guard !== null) {
-      tmplBlock = import_typescript82.default.factory.createIfStatement(guard, tmplBlock);
+      tmplBlock = import_typescript81.default.factory.createIfStatement(guard, tmplBlock);
     }
     this.scope.addStatement(tmplBlock);
     return null;
@@ -30448,7 +30427,7 @@ var TcbTextInterpolationOp = class extends TcbOp {
   }
   execute() {
     const expr = tcbExpression(this.binding.value, this.tcb, this.scope);
-    this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(expr));
+    this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(expr));
     return null;
   }
 };
@@ -30470,11 +30449,11 @@ var TcbDirectiveTypeOpBase = class extends TcbOp {
     if (this.dir.isGeneric === false || dirRef.node.typeParameters === void 0) {
       type = rawType;
     } else {
-      if (!import_typescript82.default.isTypeReferenceNode(rawType)) {
+      if (!import_typescript81.default.isTypeReferenceNode(rawType)) {
         throw new Error(`Expected TypeReferenceNode when referencing the type for ${this.dir.ref.debugName}`);
       }
-      const typeArguments = dirRef.node.typeParameters.map(() => import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword));
-      type = import_typescript82.default.factory.createTypeReferenceNode(rawType.typeName, typeArguments);
+      const typeArguments = dirRef.node.typeParameters.map(() => import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword));
+      type = import_typescript81.default.factory.createTypeReferenceNode(rawType.typeName, typeArguments);
     }
     const id = this.tcb.allocateId();
     addExpressionIdentifier(type, ExpressionIdentifier.DIRECTIVE);
@@ -30515,11 +30494,11 @@ var TcbReferenceOp = class extends TcbOp {
     const id = this.tcb.allocateId();
     let initializer = this.target instanceof Template || this.target instanceof Element ? this.scope.resolve(this.target) : this.scope.resolve(this.host, this.target);
     if (this.target instanceof Element && !this.tcb.env.config.checkTypeOfDomReferences || !this.tcb.env.config.checkTypeOfNonDomReferences) {
-      initializer = import_typescript82.default.factory.createAsExpression(initializer, import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword));
+      initializer = import_typescript81.default.factory.createAsExpression(initializer, import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword));
     } else if (this.target instanceof Template) {
-      initializer = import_typescript82.default.factory.createAsExpression(initializer, import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword));
-      initializer = import_typescript82.default.factory.createAsExpression(initializer, this.tcb.env.referenceExternalType("@angular/core", "TemplateRef", [DYNAMIC_TYPE]));
-      initializer = import_typescript82.default.factory.createParenthesizedExpression(initializer);
+      initializer = import_typescript81.default.factory.createAsExpression(initializer, import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword));
+      initializer = import_typescript81.default.factory.createAsExpression(initializer, this.tcb.env.referenceExternalType("@angular/core", "TemplateRef", [DYNAMIC_TYPE]));
+      initializer = import_typescript81.default.factory.createParenthesizedExpression(initializer);
     }
     addParseSpanInfo(initializer, this.node.sourceSpan);
     addParseSpanInfo(id, this.node.keySpan);
@@ -30609,7 +30588,7 @@ var TcbDirectiveInputsOp = class extends TcbOp {
         let target;
         if (this.dir.coercedInputFields.has(fieldName)) {
           const dirTypeRef = this.tcb.env.referenceType(this.dir.ref);
-          if (!import_typescript82.default.isTypeReferenceNode(dirTypeRef)) {
+          if (!import_typescript81.default.isTypeReferenceNode(dirTypeRef)) {
             throw new Error(`Expected TypeReferenceNode from reference to ${this.dir.ref.debugName}`);
           }
           const id = this.tcb.allocateId();
@@ -30624,10 +30603,10 @@ var TcbDirectiveInputsOp = class extends TcbOp {
           }
           const id = this.tcb.allocateId();
           const dirTypeRef = this.tcb.env.referenceType(this.dir.ref);
-          if (!import_typescript82.default.isTypeReferenceNode(dirTypeRef)) {
+          if (!import_typescript81.default.isTypeReferenceNode(dirTypeRef)) {
             throw new Error(`Expected TypeReferenceNode from reference to ${this.dir.ref.debugName}`);
           }
-          const type = import_typescript82.default.factory.createIndexedAccessTypeNode(import_typescript82.default.factory.createTypeQueryNode(dirId), import_typescript82.default.factory.createLiteralTypeNode(import_typescript82.default.factory.createStringLiteral(fieldName)));
+          const type = import_typescript81.default.factory.createIndexedAccessTypeNode(import_typescript81.default.factory.createTypeQueryNode(dirId), import_typescript81.default.factory.createLiteralTypeNode(import_typescript81.default.factory.createStringLiteral(fieldName)));
           const temp = tsDeclareVariable(id, type);
           this.scope.addStatement(temp);
           target = id;
@@ -30635,18 +30614,18 @@ var TcbDirectiveInputsOp = class extends TcbOp {
           if (dirId === null) {
             dirId = this.scope.resolve(this.node, this.dir);
           }
-          target = this.dir.stringLiteralInputFields.has(fieldName) ? import_typescript82.default.factory.createElementAccessExpression(dirId, import_typescript82.default.factory.createStringLiteral(fieldName)) : import_typescript82.default.factory.createPropertyAccessExpression(dirId, import_typescript82.default.factory.createIdentifier(fieldName));
+          target = this.dir.stringLiteralInputFields.has(fieldName) ? import_typescript81.default.factory.createElementAccessExpression(dirId, import_typescript81.default.factory.createStringLiteral(fieldName)) : import_typescript81.default.factory.createPropertyAccessExpression(dirId, import_typescript81.default.factory.createIdentifier(fieldName));
         }
         if (input.attribute.keySpan !== void 0) {
           addParseSpanInfo(target, input.attribute.keySpan);
         }
-        assignment = import_typescript82.default.factory.createBinaryExpression(target, import_typescript82.default.SyntaxKind.EqualsToken, assignment);
+        assignment = import_typescript81.default.factory.createBinaryExpression(target, import_typescript81.default.SyntaxKind.EqualsToken, assignment);
       }
       addParseSpanInfo(assignment, input.attribute.sourceSpan);
       if (!this.tcb.env.config.checkTypeOfAttributes && input.attribute instanceof TextAttribute) {
         markIgnoreDiagnostics(assignment);
       }
-      this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(assignment));
+      this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(assignment));
     }
     return null;
   }
@@ -30665,7 +30644,7 @@ var TcbDirectiveCtorCircularFallbackOp = class extends TcbOp {
   execute() {
     const id = this.tcb.allocateId();
     const typeCtor = this.tcb.env.typeCtorFor(this.dir);
-    const circularPlaceholder = import_typescript82.default.factory.createCallExpression(typeCtor, void 0, [import_typescript82.default.factory.createNonNullExpression(import_typescript82.default.factory.createNull())]);
+    const circularPlaceholder = import_typescript81.default.factory.createCallExpression(typeCtor, void 0, [import_typescript81.default.factory.createNonNullExpression(import_typescript81.default.factory.createNull())]);
     this.scope.addStatement(tsCreateVariable(id, circularPlaceholder));
     return id;
   }
@@ -30733,15 +30712,15 @@ var TcbUnclaimedInputsOp = class extends TcbOp {
             elId = this.scope.resolve(this.element);
           }
           const propertyName = (_a = ATTR_TO_PROP.get(binding.name)) != null ? _a : binding.name;
-          const prop = import_typescript82.default.factory.createElementAccessExpression(elId, import_typescript82.default.factory.createStringLiteral(propertyName));
-          const stmt = import_typescript82.default.factory.createBinaryExpression(prop, import_typescript82.default.SyntaxKind.EqualsToken, wrapForDiagnostics(expr));
+          const prop = import_typescript81.default.factory.createElementAccessExpression(elId, import_typescript81.default.factory.createStringLiteral(propertyName));
+          const stmt = import_typescript81.default.factory.createBinaryExpression(prop, import_typescript81.default.SyntaxKind.EqualsToken, wrapForDiagnostics(expr));
           addParseSpanInfo(stmt, binding.sourceSpan);
-          this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(stmt));
+          this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(stmt));
         } else {
-          this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(expr));
+          this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(expr));
         }
       } else {
-        this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(expr));
+        this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(expr));
       }
     }
     return null;
@@ -30773,18 +30752,18 @@ var TcbDirectiveOutputsOp = class extends TcbOp {
       if (dirId === null) {
         dirId = this.scope.resolve(this.node, this.dir);
       }
-      const outputField = import_typescript82.default.factory.createElementAccessExpression(dirId, import_typescript82.default.factory.createStringLiteral(field));
+      const outputField = import_typescript81.default.factory.createElementAccessExpression(dirId, import_typescript81.default.factory.createStringLiteral(field));
       addParseSpanInfo(outputField, output.keySpan);
       if (this.tcb.env.config.checkTypeOfOutputEvents) {
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 0);
-        const subscribeFn = import_typescript82.default.factory.createPropertyAccessExpression(outputField, "subscribe");
-        const call = import_typescript82.default.factory.createCallExpression(subscribeFn, void 0, [handler]);
+        const subscribeFn = import_typescript81.default.factory.createPropertyAccessExpression(outputField, "subscribe");
+        const call = import_typescript81.default.factory.createCallExpression(subscribeFn, void 0, [handler]);
         addParseSpanInfo(call, output.sourceSpan);
-        this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(call));
+        this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(call));
       } else {
-        this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(outputField));
+        this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(outputField));
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 1);
-        this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(handler));
+        this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(handler));
       }
       ExpressionSemanticVisitor.visit(output.handler, this.tcb.id, this.tcb.boundTarget, this.tcb.oobRecorder);
     }
@@ -30817,24 +30796,24 @@ var TcbUnclaimedOutputsOp = class extends TcbOp {
       if (output.type === 1) {
         const eventType = this.tcb.env.config.checkTypeOfAnimationEvents ? this.tcb.env.referenceExternalType("@angular/animations", "AnimationEvent") : 1;
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, eventType);
-        this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(handler));
+        this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(handler));
       } else if (this.tcb.env.config.checkTypeOfDomEvents) {
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 0);
         if (elId === null) {
           elId = this.scope.resolve(this.element);
         }
-        const propertyAccess = import_typescript82.default.factory.createPropertyAccessExpression(elId, "addEventListener");
+        const propertyAccess = import_typescript81.default.factory.createPropertyAccessExpression(elId, "addEventListener");
         addParseSpanInfo(propertyAccess, output.keySpan);
-        const call = import_typescript82.default.factory.createCallExpression(
+        const call = import_typescript81.default.factory.createCallExpression(
           propertyAccess,
           void 0,
-          [import_typescript82.default.factory.createStringLiteral(output.name), handler]
+          [import_typescript81.default.factory.createStringLiteral(output.name), handler]
         );
         addParseSpanInfo(call, output.sourceSpan);
-        this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(call));
+        this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(call));
       } else {
         const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 1);
-        this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(handler));
+        this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(handler));
       }
       ExpressionSemanticVisitor.visit(output.handler, this.tcb.id, this.tcb.boundTarget, this.tcb.oobRecorder);
     }
@@ -30848,15 +30827,15 @@ var TcbComponentContextCompletionOp = class extends TcbOp {
     this.optional = false;
   }
   execute() {
-    const ctx = import_typescript82.default.factory.createThis();
-    const ctxDot = import_typescript82.default.factory.createPropertyAccessExpression(ctx, "");
+    const ctx = import_typescript81.default.factory.createThis();
+    const ctxDot = import_typescript81.default.factory.createPropertyAccessExpression(ctx, "");
     markIgnoreDiagnostics(ctxDot);
     addExpressionIdentifier(ctxDot, ExpressionIdentifier.COMPONENT_COMPLETION);
-    this.scope.addStatement(import_typescript82.default.factory.createExpressionStatement(ctxDot));
+    this.scope.addStatement(import_typescript81.default.factory.createExpressionStatement(ctxDot));
     return null;
   }
 };
-var INFER_TYPE_FOR_CIRCULAR_OP_EXPR = import_typescript82.default.factory.createNonNullExpression(import_typescript82.default.factory.createNull());
+var INFER_TYPE_FOR_CIRCULAR_OP_EXPR = import_typescript81.default.factory.createNonNullExpression(import_typescript81.default.factory.createNull());
 var Context2 = class {
   constructor(env, domSchemaChecker, oobRecorder, id, boundTarget, pipes, schemas, hostIsStandalone) {
     this.env = env;
@@ -30870,7 +30849,7 @@ var Context2 = class {
     this.nextId = 1;
   }
   allocateId() {
-    return import_typescript82.default.factory.createIdentifier(`_t${this.nextId++}`);
+    return import_typescript81.default.factory.createIdentifier(`_t${this.nextId++}`);
   }
   getPipeByName(name) {
     if (!this.pipes.has(name)) {
@@ -30923,16 +30902,16 @@ var Scope2 = class {
     const res = this.resolveLocal(node, directive);
     if (res !== null) {
       let clone;
-      if (import_typescript82.default.isIdentifier(res)) {
-        clone = import_typescript82.default.factory.createIdentifier(res.text);
-      } else if (import_typescript82.default.isNonNullExpression(res)) {
-        clone = import_typescript82.default.factory.createNonNullExpression(res.expression);
+      if (import_typescript81.default.isIdentifier(res)) {
+        clone = import_typescript81.default.factory.createIdentifier(res.text);
+      } else if (import_typescript81.default.isNonNullExpression(res)) {
+        clone = import_typescript81.default.factory.createNonNullExpression(res.expression);
       } else {
         throw new Error(`Could not resolve ${node} to an Identifier or a NonNullExpression`);
       }
-      import_typescript82.default.setOriginalNode(clone, res);
+      import_typescript81.default.setOriginalNode(clone, res);
       clone.parent = clone.parent;
-      return import_typescript82.default.setSyntheticTrailingComments(clone, []);
+      return import_typescript81.default.setSyntheticTrailingComments(clone, []);
     } else if (this.parent !== null) {
       return this.parent.resolve(node, directive);
     } else {
@@ -30959,7 +30938,7 @@ var Scope2 = class {
     } else if (parentGuards === null) {
       return this.guard;
     } else {
-      return import_typescript82.default.factory.createBinaryExpression(parentGuards, import_typescript82.default.SyntaxKind.AmpersandAmpersandToken, this.guard);
+      return import_typescript81.default.factory.createBinaryExpression(parentGuards, import_typescript81.default.SyntaxKind.AmpersandAmpersandToken, this.guard);
     }
   }
   resolveLocal(ref, directive) {
@@ -31139,12 +31118,12 @@ var Scope2 = class {
   }
 };
 function tcbThisParam(name, typeArguments) {
-  return createParameterDeclaration(
+  return import_typescript81.default.factory.createParameterDeclaration(
     void 0,
     void 0,
     "this",
     void 0,
-    import_typescript82.default.factory.createTypeReferenceNode(name, typeArguments),
+    import_typescript81.default.factory.createTypeReferenceNode(name, typeArguments),
     void 0
   );
 }
@@ -31169,11 +31148,11 @@ var TcbExpressionTranslator = class {
         return null;
       }
       const expr = this.translate(ast.value);
-      const result = import_typescript82.default.factory.createParenthesizedExpression(import_typescript82.default.factory.createBinaryExpression(target, import_typescript82.default.SyntaxKind.EqualsToken, expr));
+      const result = import_typescript81.default.factory.createParenthesizedExpression(import_typescript81.default.factory.createBinaryExpression(target, import_typescript81.default.SyntaxKind.EqualsToken, expr));
       addParseSpanInfo(result, ast.sourceSpan);
       return result;
     } else if (ast instanceof ImplicitReceiver) {
-      return import_typescript82.default.factory.createThis();
+      return import_typescript81.default.factory.createThis();
     } else if (ast instanceof BindingPipe) {
       const expr = this.translate(ast.exp);
       const pipeRef = this.tcb.getPipeByName(ast.name);
@@ -31185,12 +31164,12 @@ var TcbExpressionTranslator = class {
         pipe = this.tcb.env.pipeInst(pipeRef);
       }
       const args = ast.args.map((arg) => this.translate(arg));
-      let methodAccess = import_typescript82.default.factory.createPropertyAccessExpression(pipe, "transform");
+      let methodAccess = import_typescript81.default.factory.createPropertyAccessExpression(pipe, "transform");
       addParseSpanInfo(methodAccess, ast.nameSpan);
       if (!this.tcb.env.config.checkTypeOfPipes) {
-        methodAccess = import_typescript82.default.factory.createAsExpression(methodAccess, import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword));
+        methodAccess = import_typescript81.default.factory.createAsExpression(methodAccess, import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword));
       }
-      const result = import_typescript82.default.factory.createCallExpression(
+      const result = import_typescript81.default.factory.createCallExpression(
         methodAccess,
         void 0,
         [expr, ...args]
@@ -31200,8 +31179,8 @@ var TcbExpressionTranslator = class {
     } else if ((ast instanceof Call || ast instanceof SafeCall) && (ast.receiver instanceof PropertyRead || ast.receiver instanceof SafePropertyRead)) {
       if (ast.receiver.receiver instanceof ImplicitReceiver && !(ast.receiver.receiver instanceof ThisReceiver) && ast.receiver.name === "$any" && ast.args.length === 1) {
         const expr = this.translate(ast.args[0]);
-        const exprAsAny = import_typescript82.default.factory.createAsExpression(expr, import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword));
-        const result = import_typescript82.default.factory.createParenthesizedExpression(exprAsAny);
+        const exprAsAny = import_typescript81.default.factory.createAsExpression(expr, import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword));
+        const result = import_typescript81.default.factory.createParenthesizedExpression(exprAsAny);
         addParseSpanInfo(result, ast.sourceSpan);
         return result;
       }
@@ -31212,7 +31191,7 @@ var TcbExpressionTranslator = class {
       const method = wrapForDiagnostics(receiver);
       addParseSpanInfo(method, ast.receiver.nameSpan);
       const args = ast.args.map((arg) => this.translate(arg));
-      const node = import_typescript82.default.factory.createCallExpression(method, void 0, args);
+      const node = import_typescript81.default.factory.createCallExpression(method, void 0, args);
       addParseSpanInfo(node, ast.sourceSpan);
       return node;
     } else {
@@ -31232,20 +31211,20 @@ var TcbExpressionTranslator = class {
 function tcbCallTypeCtor(dir, tcb, inputs) {
   const typeCtor = tcb.env.typeCtorFor(dir);
   const members = inputs.map((input) => {
-    const propertyName = import_typescript82.default.factory.createStringLiteral(input.field);
+    const propertyName = import_typescript81.default.factory.createStringLiteral(input.field);
     if (input.type === "binding") {
       const expr = widenBinding(input.expression, tcb);
-      const assignment = import_typescript82.default.factory.createPropertyAssignment(propertyName, wrapForDiagnostics(expr));
+      const assignment = import_typescript81.default.factory.createPropertyAssignment(propertyName, wrapForDiagnostics(expr));
       addParseSpanInfo(assignment, input.sourceSpan);
       return assignment;
     } else {
-      return import_typescript82.default.factory.createPropertyAssignment(propertyName, NULL_AS_ANY);
+      return import_typescript81.default.factory.createPropertyAssignment(propertyName, NULL_AS_ANY);
     }
   });
-  return import_typescript82.default.factory.createCallExpression(
+  return import_typescript81.default.factory.createCallExpression(
     typeCtor,
     void 0,
-    [import_typescript82.default.factory.createObjectLiteralExpression(members)]
+    [import_typescript81.default.factory.createObjectLiteralExpression(members)]
   );
 }
 function getBoundInputs(directive, node, tcb) {
@@ -31272,17 +31251,17 @@ function translateInput(attr, tcb, scope) {
   if (attr instanceof BoundAttribute) {
     return tcbExpression(attr.value, tcb, scope);
   } else {
-    return import_typescript82.default.factory.createStringLiteral(attr.value);
+    return import_typescript81.default.factory.createStringLiteral(attr.value);
   }
 }
 function widenBinding(expr, tcb) {
   if (!tcb.env.config.checkTypeOfInputBindings) {
     return tsCastToAny(expr);
   } else if (!tcb.env.config.strictNullInputBindings) {
-    if (import_typescript82.default.isObjectLiteralExpression(expr) || import_typescript82.default.isArrayLiteralExpression(expr)) {
+    if (import_typescript81.default.isObjectLiteralExpression(expr) || import_typescript81.default.isArrayLiteralExpression(expr)) {
       return expr;
     } else {
-      return import_typescript82.default.factory.createNonNullExpression(expr);
+      return import_typescript81.default.factory.createNonNullExpression(expr);
     }
   } else {
     return expr;
@@ -31295,16 +31274,16 @@ function tcbCreateEventHandler(event, tcb, scope, eventType) {
   if (eventType === 0) {
     eventParamType = void 0;
   } else if (eventType === 1) {
-    eventParamType = import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword);
+    eventParamType = import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword);
   } else {
     eventParamType = eventType;
   }
   const guards = scope.guards();
-  let body = import_typescript82.default.factory.createExpressionStatement(handler);
+  let body = import_typescript81.default.factory.createExpressionStatement(handler);
   if (guards !== null) {
-    body = import_typescript82.default.factory.createIfStatement(guards, body);
+    body = import_typescript81.default.factory.createIfStatement(guards, body);
   }
-  const eventParam = createParameterDeclaration(
+  const eventParam = import_typescript81.default.factory.createParameterDeclaration(
     void 0,
     void 0,
     EVENT_PARAMETER,
@@ -31312,13 +31291,13 @@ function tcbCreateEventHandler(event, tcb, scope, eventType) {
     eventParamType
   );
   addExpressionIdentifier(eventParam, ExpressionIdentifier.EVENT_PARAMETER);
-  return import_typescript82.default.factory.createArrowFunction(
+  return import_typescript81.default.factory.createArrowFunction(
     void 0,
     void 0,
     [eventParam],
-    import_typescript82.default.factory.createKeywordTypeNode(import_typescript82.default.SyntaxKind.AnyKeyword),
+    import_typescript81.default.factory.createKeywordTypeNode(import_typescript81.default.SyntaxKind.AnyKeyword),
     void 0,
-    import_typescript82.default.factory.createBlock([body])
+    import_typescript81.default.factory.createBlock([body])
   );
 }
 function tcbEventHandlerExpression(ast, tcb, scope) {
@@ -31347,7 +31326,7 @@ function isSplitTwoWayBinding(inputName, output, inputs, tcb) {
 var TcbEventHandlerTranslator = class extends TcbExpressionTranslator {
   resolve(ast) {
     if (ast instanceof PropertyRead && ast.receiver instanceof ImplicitReceiver && !(ast.receiver instanceof ThisReceiver) && ast.name === EVENT_PARAMETER) {
-      const event = import_typescript82.default.factory.createIdentifier(EVENT_PARAMETER);
+      const event = import_typescript81.default.factory.createIdentifier(EVENT_PARAMETER);
       addParseSpanInfo(event, ast.nameSpan);
       return event;
     }
@@ -31356,32 +31335,32 @@ var TcbEventHandlerTranslator = class extends TcbExpressionTranslator {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_check_file.mjs
-var import_typescript83 = __toESM(require("typescript"), 1);
+var import_typescript82 = __toESM(require("typescript"), 1);
 var TypeCheckFile = class extends Environment {
   constructor(fileName, config, refEmitter, reflector, compilerHost) {
-    super(config, new ImportManager(new NoopImportRewriter(), "i"), refEmitter, reflector, import_typescript83.default.createSourceFile(compilerHost.getCanonicalFileName(fileName), "", import_typescript83.default.ScriptTarget.Latest, true));
+    super(config, new ImportManager(new NoopImportRewriter(), "i"), refEmitter, reflector, import_typescript82.default.createSourceFile(compilerHost.getCanonicalFileName(fileName), "", import_typescript82.default.ScriptTarget.Latest, true));
     this.fileName = fileName;
     this.nextTcbId = 1;
     this.tcbStatements = [];
   }
   addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
-    const fnId = import_typescript83.default.factory.createIdentifier(`_tcb${this.nextTcbId++}`);
+    const fnId = import_typescript82.default.factory.createIdentifier(`_tcb${this.nextTcbId++}`);
     const fn2 = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);
     this.tcbStatements.push(fn2);
   }
   render(removeComments) {
     let source = this.importManager.getAllImports(this.contextFile.fileName).map((i) => `import * as ${i.qualifier.text} from '${i.specifier}';`).join("\n") + "\n\n";
-    const printer = import_typescript83.default.createPrinter({ removeComments });
+    const printer = import_typescript82.default.createPrinter({ removeComments });
     source += "\n";
     for (const stmt of this.pipeInstStatements) {
-      source += printer.printNode(import_typescript83.default.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
+      source += printer.printNode(import_typescript82.default.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
     }
     for (const stmt of this.typeCtorStatements) {
-      source += printer.printNode(import_typescript83.default.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
+      source += printer.printNode(import_typescript82.default.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
     }
     source += "\n";
     for (const stmt of this.tcbStatements) {
-      source += printer.printNode(import_typescript83.default.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
+      source += printer.printNode(import_typescript82.default.EmitHint.Unspecified, stmt, this.contextFile) + "\n";
     }
     source += "\nexport const IS_A_MODULE = true;\n";
     return source;
@@ -31497,7 +31476,7 @@ var TypeCheckContextImpl = class {
     const importManager = new ImportManager(new NoopImportRewriter(), "_i");
     const ops = this.opMap.get(sf).sort(orderOps);
     const textParts = splitStringAtPoints(sf.text, ops.map((op) => op.splitPoint));
-    const printer = import_typescript84.default.createPrinter({ omitTrailingSemicolon: true });
+    const printer = import_typescript83.default.createPrinter({ omitTrailingSemicolon: true });
     let code = textParts[0];
     ops.forEach((op, idx) => {
       const text = op.execute(importManager, sf, this.refEmitter, printer);
@@ -31578,7 +31557,7 @@ var TypeCheckContextImpl = class {
       if (span.start.offset === span.end.offset) {
         span.end.offset++;
       }
-      return makeTemplateDiagnostic(templateId, sourceMapping, span, import_typescript84.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.TEMPLATE_PARSE_ERROR), error2.msg);
+      return makeTemplateDiagnostic(templateId, sourceMapping, span, import_typescript83.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.TEMPLATE_PARSE_ERROR), error2.msg);
     });
   }
 };
@@ -31596,9 +31575,9 @@ var InlineTcbOp = class {
   }
   execute(im, sf, refEmitter, printer) {
     const env = new Environment(this.config, im, refEmitter, this.reflector, sf);
-    const fnName = import_typescript84.default.factory.createIdentifier(`_tcb_${this.ref.node.pos}`);
+    const fnName = import_typescript83.default.factory.createIdentifier(`_tcb_${this.ref.node.pos}`);
     const fn2 = generateTypeCheckBlock(env, this.ref, fnName, this.meta, this.domSchemaChecker, this.oobRecorder, TcbGenericContextBehavior.CopyClassNodes);
-    return printer.printNode(import_typescript84.default.EmitHint.Unspecified, fn2, sf);
+    return printer.printNode(import_typescript83.default.EmitHint.Unspecified, fn2, sf);
   }
 };
 var TypeCtorOp = class {
@@ -31611,7 +31590,7 @@ var TypeCtorOp = class {
   }
   execute(im, sf, refEmitter, printer) {
     const tcb = generateInlineTypeCtor(this.ref.node, this.meta);
-    return printer.printNode(import_typescript84.default.EmitHint.Unspecified, tcb, sf);
+    return printer.printNode(import_typescript83.default.EmitHint.Unspecified, tcb, sf);
   }
 };
 function orderOps(op1, op2) {
@@ -31722,7 +31701,7 @@ var TemplateSourceManager = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/template_symbol_builder.mjs
-var import_typescript85 = __toESM(require("typescript"), 1);
+var import_typescript84 = __toESM(require("typescript"), 1);
 var SymbolBuilder = class {
   constructor(tcbPath, tcbIsShim, typeCheckBlock, templateData, componentScopeReader, getTypeChecker) {
     this.tcbPath = tcbPath;
@@ -31766,7 +31745,7 @@ var SymbolBuilder = class {
   getSymbolOfElement(element) {
     var _a;
     const elementSourceSpan = (_a = element.startSourceSpan) != null ? _a : element.sourceSpan;
-    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: elementSourceSpan, filter: import_typescript85.default.isVariableDeclaration });
+    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: elementSourceSpan, filter: import_typescript84.default.isVariableDeclaration });
     if (node === null) {
       return null;
     }
@@ -31785,12 +31764,12 @@ var SymbolBuilder = class {
     var _a;
     const elementSourceSpan = (_a = element.startSourceSpan) != null ? _a : element.sourceSpan;
     const tcbSourceFile = this.typeCheckBlock.getSourceFile();
-    const isDirectiveDeclaration = (node) => (import_typescript85.default.isTypeNode(node) || import_typescript85.default.isIdentifier(node)) && import_typescript85.default.isVariableDeclaration(node.parent) && hasExpressionIdentifier(tcbSourceFile, node, ExpressionIdentifier.DIRECTIVE);
+    const isDirectiveDeclaration = (node) => (import_typescript84.default.isTypeNode(node) || import_typescript84.default.isIdentifier(node)) && import_typescript84.default.isVariableDeclaration(node.parent) && hasExpressionIdentifier(tcbSourceFile, node, ExpressionIdentifier.DIRECTIVE);
     const nodes = findAllMatchingNodes(this.typeCheckBlock, { withSpan: elementSourceSpan, filter: isDirectiveDeclaration });
     const symbols = [];
     for (const node of nodes) {
       const symbol = this.getSymbolOfTsNode(node.parent);
-      if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !import_typescript85.default.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
+      if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !import_typescript84.default.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
         continue;
       }
       const meta = this.getDirectiveMeta(element, symbol.tsSymbol.valueDeclaration);
@@ -31817,7 +31796,7 @@ var SymbolBuilder = class {
   }
   addHostDirectiveSymbols(host, hostDirectives, symbols) {
     for (const current of hostDirectives) {
-      if (!import_typescript85.default.isClassDeclaration(current.directive.node)) {
+      if (!import_typescript84.default.isClassDeclaration(current.directive.node)) {
         continue;
       }
       const symbol = this.getSymbolOfTsNode(current.directive.node);
@@ -31889,17 +31868,17 @@ var SymbolBuilder = class {
       if (!isAccessExpression(n)) {
         return false;
       }
-      if (import_typescript85.default.isPropertyAccessExpression(n)) {
+      if (import_typescript84.default.isPropertyAccessExpression(n)) {
         return n.name.getText() === expectedAccess;
       } else {
-        return import_typescript85.default.isStringLiteral(n.argumentExpression) && n.argumentExpression.text === expectedAccess;
+        return import_typescript84.default.isStringLiteral(n.argumentExpression) && n.argumentExpression.text === expectedAccess;
       }
     }
     const outputFieldAccesses = findAllMatchingNodes(this.typeCheckBlock, { withSpan: eventBinding.keySpan, filter });
     const bindings = [];
     for (const outputFieldAccess of outputFieldAccesses) {
       if (consumer instanceof Template || consumer instanceof Element) {
-        if (!import_typescript85.default.isPropertyAccessExpression(outputFieldAccess)) {
+        if (!import_typescript84.default.isPropertyAccessExpression(outputFieldAccess)) {
           continue;
         }
         const addEventListener = outputFieldAccess.name;
@@ -31922,7 +31901,7 @@ var SymbolBuilder = class {
           }
         });
       } else {
-        if (!import_typescript85.default.isElementAccessExpression(outputFieldAccess)) {
+        if (!import_typescript84.default.isElementAccessExpression(outputFieldAccess)) {
           continue;
         }
         const tsSymbol = this.getTypeChecker().getSymbolAtLocation(outputFieldAccess.argumentExpression);
@@ -31994,7 +31973,7 @@ var SymbolBuilder = class {
       return null;
     }
     const [declaration] = tsSymbol.declarations;
-    if (!import_typescript85.default.isVariableDeclaration(declaration) || !hasExpressionIdentifier(
+    if (!import_typescript84.default.isVariableDeclaration(declaration) || !hasExpressionIdentifier(
       declaration.getSourceFile(),
       (_a = declaration.type) != null ? _a : declaration.name,
       ExpressionIdentifier.DIRECTIVE
@@ -32002,7 +31981,7 @@ var SymbolBuilder = class {
       return null;
     }
     const symbol = this.getSymbolOfTsNode(declaration);
-    if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !import_typescript85.default.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
+    if (symbol === null || !isSymbolWithValueDeclaration(symbol.tsSymbol) || !import_typescript84.default.isClassDeclaration(symbol.tsSymbol.valueDeclaration)) {
       return null;
     }
     const ref = new Reference2(symbol.tsSymbol.valueDeclaration);
@@ -32022,7 +32001,7 @@ var SymbolBuilder = class {
     };
   }
   getSymbolOfVariable(variable2) {
-    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: variable2.sourceSpan, filter: import_typescript85.default.isVariableDeclaration });
+    const node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: variable2.sourceSpan, filter: import_typescript84.default.isVariableDeclaration });
     if (node === null || node.initializer === void 0) {
       return null;
     }
@@ -32045,11 +32024,11 @@ var SymbolBuilder = class {
   }
   getSymbolOfReference(ref) {
     const target = this.templateData.boundTarget.getReferenceTarget(ref);
-    let node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: ref.sourceSpan, filter: import_typescript85.default.isVariableDeclaration });
+    let node = findFirstMatchingNode(this.typeCheckBlock, { withSpan: ref.sourceSpan, filter: import_typescript84.default.isVariableDeclaration });
     if (node === null || target === null || node.initializer === void 0) {
       return null;
     }
-    const originalDeclaration = import_typescript85.default.isParenthesizedExpression(node.initializer) && import_typescript85.default.isAsExpression(node.initializer.expression) ? this.getTypeChecker().getSymbolAtLocation(node.name) : this.getTypeChecker().getSymbolAtLocation(node.initializer);
+    const originalDeclaration = import_typescript84.default.isParenthesizedExpression(node.initializer) && import_typescript84.default.isAsExpression(node.initializer.expression) ? this.getTypeChecker().getSymbolAtLocation(node.name) : this.getTypeChecker().getSymbolAtLocation(node.initializer);
     if (originalDeclaration === void 0 || originalDeclaration.valueDeclaration === void 0) {
       return null;
     }
@@ -32073,7 +32052,7 @@ var SymbolBuilder = class {
         referenceVarLocation: referenceVarTcbLocation
       };
     } else {
-      if (!import_typescript85.default.isClassDeclaration(target.directive.ref.node)) {
+      if (!import_typescript84.default.isClassDeclaration(target.directive.ref.node)) {
         return null;
       }
       return {
@@ -32088,7 +32067,7 @@ var SymbolBuilder = class {
     }
   }
   getSymbolOfPipe(expression) {
-    const methodAccess = findFirstMatchingNode(this.typeCheckBlock, { withSpan: expression.nameSpan, filter: import_typescript85.default.isPropertyAccessExpression });
+    const methodAccess = findFirstMatchingNode(this.typeCheckBlock, { withSpan: expression.nameSpan, filter: import_typescript84.default.isPropertyAccessExpression });
     if (methodAccess === null) {
       return null;
     }
@@ -32127,7 +32106,7 @@ var SymbolBuilder = class {
     }
     let node = null;
     if (expression instanceof PropertyRead) {
-      node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: import_typescript85.default.isPropertyAccessExpression });
+      node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: import_typescript84.default.isPropertyAccessExpression });
     }
     if (node === null) {
       node = findFirstMatchingNode(this.typeCheckBlock, { withSpan, filter: anyNodeFilter });
@@ -32135,10 +32114,10 @@ var SymbolBuilder = class {
     if (node === null) {
       return null;
     }
-    while (import_typescript85.default.isParenthesizedExpression(node)) {
+    while (import_typescript84.default.isParenthesizedExpression(node)) {
       node = node.expression;
     }
-    if (expression instanceof SafePropertyRead && import_typescript85.default.isConditionalExpression(node)) {
+    if (expression instanceof SafePropertyRead && import_typescript84.default.isConditionalExpression(node)) {
       const whenTrueSymbol = this.getSymbolOfTsNode(node.whenTrue);
       if (whenTrueSymbol === null) {
         return null;
@@ -32154,13 +32133,13 @@ var SymbolBuilder = class {
   }
   getSymbolOfTsNode(node) {
     var _a;
-    while (import_typescript85.default.isParenthesizedExpression(node)) {
+    while (import_typescript84.default.isParenthesizedExpression(node)) {
       node = node.expression;
     }
     let tsSymbol;
-    if (import_typescript85.default.isPropertyAccessExpression(node)) {
+    if (import_typescript84.default.isPropertyAccessExpression(node)) {
       tsSymbol = this.getTypeChecker().getSymbolAtLocation(node.name);
-    } else if (import_typescript85.default.isElementAccessExpression(node)) {
+    } else if (import_typescript84.default.isElementAccessExpression(node)) {
       tsSymbol = this.getTypeChecker().getSymbolAtLocation(node.argumentExpression);
     } else {
       tsSymbol = this.getTypeChecker().getSymbolAtLocation(node);
@@ -32178,13 +32157,13 @@ var SymbolBuilder = class {
     };
   }
   getTcbPositionForNode(node) {
-    if (import_typescript85.default.isTypeReferenceNode(node)) {
+    if (import_typescript84.default.isTypeReferenceNode(node)) {
       return this.getTcbPositionForNode(node.typeName);
-    } else if (import_typescript85.default.isQualifiedName(node)) {
+    } else if (import_typescript84.default.isQualifiedName(node)) {
       return node.right.getStart();
-    } else if (import_typescript85.default.isPropertyAccessExpression(node)) {
+    } else if (import_typescript84.default.isPropertyAccessExpression(node)) {
       return node.name.getStart();
-    } else if (import_typescript85.default.isElementAccessExpression(node)) {
+    } else if (import_typescript84.default.isElementAccessExpression(node)) {
       return node.argumentExpression.getStart();
     } else {
       return node.getStart();
@@ -33069,7 +33048,7 @@ var factory3 = {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable/index.mjs
-var import_typescript88 = __toESM(require("typescript"), 1);
+var import_typescript87 = __toESM(require("typescript"), 1);
 var NullishCoalescingNotNullableCheck = class extends TemplateCheckWithVisitor {
   constructor() {
     super(...arguments);
@@ -33083,7 +33062,7 @@ var NullishCoalescingNotNullableCheck = class extends TemplateCheckWithVisitor {
       return [];
     }
     const typeLeft = symbolLeft.tsType;
-    if (typeLeft.flags & (import_typescript88.default.TypeFlags.Any | import_typescript88.default.TypeFlags.Unknown)) {
+    if (typeLeft.flags & (import_typescript87.default.TypeFlags.Any | import_typescript87.default.TypeFlags.Unknown)) {
       return [];
     }
     if (typeLeft.getNonNullableType() !== typeLeft)
@@ -33113,7 +33092,7 @@ var factory4 = {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/extended/checks/optional_chain_not_nullable/index.mjs
-var import_typescript89 = __toESM(require("typescript"), 1);
+var import_typescript88 = __toESM(require("typescript"), 1);
 var OptionalChainNotNullableCheck = class extends TemplateCheckWithVisitor {
   constructor() {
     super(...arguments);
@@ -33127,7 +33106,7 @@ var OptionalChainNotNullableCheck = class extends TemplateCheckWithVisitor {
       return [];
     }
     const typeLeft = symbolLeft.tsType;
-    if (typeLeft.flags & (import_typescript89.default.TypeFlags.Any | import_typescript89.default.TypeFlags.Unknown)) {
+    if (typeLeft.flags & (import_typescript88.default.TypeFlags.Any | import_typescript88.default.TypeFlags.Unknown)) {
       return [];
     }
     if (typeLeft.getNonNullableType() !== typeLeft)
@@ -33219,7 +33198,7 @@ var factory7 = {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker.mjs
-var import_typescript90 = __toESM(require("typescript"), 1);
+var import_typescript89 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/api/src/public_options.mjs
 var DiagnosticCategoryLabel;
@@ -33267,9 +33246,9 @@ var ExtendedTemplateCheckerImpl = class {
 function diagnosticLabelToCategory(label) {
   switch (label) {
     case DiagnosticCategoryLabel.Warning:
-      return import_typescript90.default.DiagnosticCategory.Warning;
+      return import_typescript89.default.DiagnosticCategory.Warning;
     case DiagnosticCategoryLabel.Error:
-      return import_typescript90.default.DiagnosticCategory.Error;
+      return import_typescript89.default.DiagnosticCategory.Error;
     case DiagnosticCategoryLabel.Suppress:
       return null;
     default:
@@ -33365,7 +33344,7 @@ var NgCompiler = class {
     this.currentProgram = inputProgram;
     this.closureCompilerEnabled = !!this.options.annotateForClosureCompiler;
     this.entryPoint = adapter.entryPoint !== null ? getSourceFileOrNull(inputProgram, adapter.entryPoint) : null;
-    const moduleResolutionCache = import_typescript91.default.createModuleResolutionCache(
+    const moduleResolutionCache = import_typescript90.default.createModuleResolutionCache(
       this.adapter.getCurrentDirectory(),
       this.adapter.getCanonicalFileName.bind(this.adapter)
     );
@@ -33412,7 +33391,7 @@ var NgCompiler = class {
       }
       for (const clazz of classesToUpdate) {
         this.compilation.traitCompiler.updateResources(clazz);
-        if (!import_typescript91.default.isClassDeclaration(clazz)) {
+        if (!import_typescript90.default.isClassDeclaration(clazz)) {
           continue;
         }
         this.compilation.templateTypeChecker.invalidateClass(clazz);
@@ -33824,18 +33803,18 @@ function isAngularCorePackage(program) {
     return false;
   }
   return r3Symbols.statements.some((stmt) => {
-    if (!import_typescript91.default.isVariableStatement(stmt)) {
+    if (!import_typescript90.default.isVariableStatement(stmt)) {
       return false;
     }
-    const modifiers = import_typescript91.default.getModifiers(stmt);
-    if (modifiers === void 0 || !modifiers.some((mod) => mod.kind === import_typescript91.default.SyntaxKind.ExportKeyword)) {
+    const modifiers = import_typescript90.default.getModifiers(stmt);
+    if (modifiers === void 0 || !modifiers.some((mod) => mod.kind === import_typescript90.default.SyntaxKind.ExportKeyword)) {
       return false;
     }
     return stmt.declarationList.declarations.some((decl) => {
-      if (!import_typescript91.default.isIdentifier(decl.name) || decl.name.text !== "ITS_JUST_ANGULAR") {
+      if (!import_typescript90.default.isIdentifier(decl.name) || decl.name.text !== "ITS_JUST_ANGULAR") {
         return false;
       }
-      if (decl.initializer === void 0 || decl.initializer.kind !== import_typescript91.default.SyntaxKind.TrueKeyword) {
+      if (decl.initializer === void 0 || decl.initializer.kind !== import_typescript90.default.SyntaxKind.TrueKeyword) {
         return false;
       }
       return true;
@@ -33849,7 +33828,7 @@ function* verifyCompatibleTypeCheckOptions(options) {
   var _a, _b, _c;
   if (options.fullTemplateTypeCheck === false && options.strictTemplates === true) {
     yield makeConfigDiagnostic({
-      category: import_typescript91.default.DiagnosticCategory.Error,
+      category: import_typescript90.default.DiagnosticCategory.Error,
       code: ErrorCode.CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK,
       messageText: `
 Angular compiler option "strictTemplates" is enabled, however "fullTemplateTypeCheck" is disabled.
@@ -33868,7 +33847,7 @@ https://angular.io/guide/template-typecheck
   }
   if (options.extendedDiagnostics && options.strictTemplates === false) {
     yield makeConfigDiagnostic({
-      category: import_typescript91.default.DiagnosticCategory.Error,
+      category: import_typescript90.default.DiagnosticCategory.Error,
       code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES,
       messageText: `
 Angular compiler option "extendedDiagnostics" is configured, however "strictTemplates" is disabled.
@@ -33885,7 +33864,7 @@ One of the following actions is required:
   const defaultCategory = (_a = options.extendedDiagnostics) == null ? void 0 : _a.defaultCategory;
   if (defaultCategory && !allowedCategoryLabels.includes(defaultCategory)) {
     yield makeConfigDiagnostic({
-      category: import_typescript91.default.DiagnosticCategory.Error,
+      category: import_typescript90.default.DiagnosticCategory.Error,
       code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL,
       messageText: `
 Angular compiler option "extendedDiagnostics.defaultCategory" has an unknown diagnostic category: "${defaultCategory}".
@@ -33899,7 +33878,7 @@ ${allowedCategoryLabels.join("\n")}
   for (const [checkName, category] of Object.entries((_c = (_b = options.extendedDiagnostics) == null ? void 0 : _b.checks) != null ? _c : {})) {
     if (!allExtendedDiagnosticNames.includes(checkName)) {
       yield makeConfigDiagnostic({
-        category: import_typescript91.default.DiagnosticCategory.Error,
+        category: import_typescript90.default.DiagnosticCategory.Error,
         code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK,
         messageText: `
 Angular compiler option "extendedDiagnostics.checks" has an unknown check: "${checkName}".
@@ -33911,7 +33890,7 @@ ${allExtendedDiagnosticNames.join("\n")}
     }
     if (!allowedCategoryLabels.includes(category)) {
       yield makeConfigDiagnostic({
-        category: import_typescript91.default.DiagnosticCategory.Error,
+        category: import_typescript90.default.DiagnosticCategory.Error,
         code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL,
         messageText: `
 Angular compiler option "extendedDiagnostics.checks['${checkName}']" has an unknown diagnostic category: "${category}".
@@ -33941,7 +33920,7 @@ var ReferenceGraphAdapter = class {
     for (const { node } of references) {
       let sourceFile = node.getSourceFile();
       if (sourceFile === void 0) {
-        sourceFile = import_typescript91.default.getOriginalNode(node).getSourceFile();
+        sourceFile = import_typescript90.default.getOriginalNode(node).getSourceFile();
       }
       if (sourceFile === void 0 || !isDtsPath(sourceFile.fileName)) {
         this.graph.add(source, node);
@@ -33980,7 +33959,7 @@ function versionMapFromProgram(program, driver) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/src/host.mjs
-var import_typescript93 = __toESM(require("typescript"), 1);
+var import_typescript92 = __toESM(require("typescript"), 1);
 var DelegatingCompilerHost2 = class {
   constructor(delegate) {
     this.delegate = delegate;
@@ -34011,6 +33990,8 @@ var DelegatingCompilerHost2 = class {
     this.writeFile = this.delegateMethod("writeFile");
     this.getModuleResolutionCache = this.delegateMethod("getModuleResolutionCache");
     this.hasInvalidatedResolutions = this.delegateMethod("hasInvalidatedResolutions");
+    this.resolveModuleNameLiterals = this.delegateMethod("resolveModuleNameLiterals");
+    this.resolveTypeReferenceDirectiveReferences = this.delegateMethod("resolveTypeReferenceDirectiveReferences");
   }
   delegateMethod(name) {
     return this.delegate[name] !== void 0 ? this.delegate[name].bind(this.delegate) : void 0;
@@ -34057,7 +34038,7 @@ var NgCompilerHost = class extends DelegatingCompilerHost2 {
       entryPoint = findFlatIndexEntryPoint(normalizedTsInputFiles);
       if (entryPoint === null) {
         diagnostics.push({
-          category: import_typescript93.default.DiagnosticCategory.Error,
+          category: import_typescript92.default.DiagnosticCategory.Error,
           code: ngErrorCode(ErrorCode.CONFIG_FLAT_MODULE_NO_INDEX),
           file: void 0,
           start: void 0,
@@ -34100,10 +34081,10 @@ var NgCompilerHost = class extends DelegatingCompilerHost2 {
     return this.fileNameToModuleName !== void 0 ? this : null;
   }
   createCachedResolveModuleNamesFunction() {
-    const moduleResolutionCache = import_typescript93.default.createModuleResolutionCache(this.getCurrentDirectory(), this.getCanonicalFileName.bind(this));
+    const moduleResolutionCache = import_typescript92.default.createModuleResolutionCache(this.getCurrentDirectory(), this.getCanonicalFileName.bind(this));
     return (moduleNames, containingFile, reusedNames, redirectedReference, options) => {
       return moduleNames.map((moduleName) => {
-        const module3 = import_typescript93.default.resolveModuleName(moduleName, containingFile, options, this, moduleResolutionCache, redirectedReference);
+        const module3 = import_typescript92.default.resolveModuleName(moduleName, containingFile, options, this, moduleResolutionCache, redirectedReference);
         return module3.resolvedModule;
       });
     };
@@ -34124,7 +34105,7 @@ var NgtscProgram = class {
     if (reuseProgram !== void 0) {
       retagAllTsFiles(reuseProgram);
     }
-    this.tsProgram = perfRecorder.inPhase(PerfPhase.TypeScriptProgramCreate, () => import_typescript95.default.createProgram(this.host.inputFiles, options, this.host, reuseProgram));
+    this.tsProgram = perfRecorder.inPhase(PerfPhase.TypeScriptProgramCreate, () => import_typescript94.default.createProgram(this.host.inputFiles, options, this.host, reuseProgram));
     perfRecorder.phase(PerfPhase.Unaccounted);
     perfRecorder.memory(PerfCheckpoint.TypeScriptProgramCreate);
     this.host.postProgramCreationCleanup();
@@ -34334,13 +34315,13 @@ function createProgram({ rootNames, options, host, oldProgram }) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/perform_compile.mjs
-var import_typescript97 = __toESM(require("typescript"), 1);
+var import_typescript96 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/util.mjs
-var import_typescript96 = __toESM(require("typescript"), 1);
+var import_typescript95 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/downlevel_decorators_transform/downlevel_decorators_transform.mjs
-var import_typescript98 = __toESM(require("typescript"), 1);
+var import_typescript97 = __toESM(require("typescript"), 1);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/private/tooling.mjs
 var GLOBAL_DEFS_FOR_TERSER = {
@@ -34377,332 +34358,118 @@ var import_fs2 = require("fs");
 var import_path8 = require("path");
 var import_typescript110 = __toESM(require("typescript"), 1);
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/project_tsconfig_paths.mjs
-var import_core13 = require("@angular-devkit/core");
-function getProjectTsConfigPaths(tree) {
-  return __async(this, null, function* () {
-    const buildPaths = /* @__PURE__ */ new Set();
-    const testPaths = /* @__PURE__ */ new Set();
-    const workspace = yield getWorkspace(tree);
-    for (const [, project] of workspace.projects) {
-      for (const [name, target] of project.targets) {
-        if (name !== "build" && name !== "test") {
-          continue;
-        }
-        for (const [, options] of allTargetOptions(target)) {
-          const tsConfig = options.tsConfig;
-          if (typeof tsConfig !== "string" || !tree.exists(tsConfig)) {
-            continue;
-          }
-          if (name === "build") {
-            buildPaths.add((0, import_core13.normalize)(tsConfig));
-          } else {
-            testPaths.add((0, import_core13.normalize)(tsConfig));
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/change_tracker.mjs
+var import_typescript99 = __toESM(require("typescript"), 1);
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/import_manager.mjs
+var import_path4 = require("path");
+var import_typescript98 = __toESM(require("typescript"), 1);
+var ImportManager2 = class {
+  constructor(getUpdateRecorder, printer) {
+    this.getUpdateRecorder = getUpdateRecorder;
+    this.printer = printer;
+    this.updatedImports = /* @__PURE__ */ new Map();
+    this.usedIdentifierNames = /* @__PURE__ */ new Map();
+    this.newImports = /* @__PURE__ */ new Map();
+    this.quoteStyles = {};
+    this.importCache = [];
+  }
+  addImportToSourceFile(sourceFile, symbolName, moduleName, alias = null, typeImport = false) {
+    const sourceDir = (0, import_path4.dirname)(sourceFile.fileName);
+    let importStartIndex = 0;
+    let existingImport = null;
+    const cachedImport = this.importCache.find((c) => c.sourceFile === sourceFile && c.symbolName === symbolName && c.moduleName === moduleName && c.alias === alias);
+    if (cachedImport) {
+      return cachedImport.identifier;
+    }
+    for (let i = sourceFile.statements.length - 1; i >= 0; i--) {
+      const statement = sourceFile.statements[i];
+      if (!import_typescript98.default.isImportDeclaration(statement) || !import_typescript98.default.isStringLiteral(statement.moduleSpecifier) || !statement.importClause) {
+        continue;
+      }
+      if (importStartIndex === 0) {
+        importStartIndex = this._getEndPositionOfNode(statement);
+      }
+      const moduleSpecifier = statement.moduleSpecifier.text;
+      if (moduleSpecifier.startsWith(".") && (0, import_path4.resolve)(sourceDir, moduleSpecifier) !== (0, import_path4.resolve)(sourceDir, moduleName) || moduleSpecifier !== moduleName) {
+        continue;
+      }
+      if (statement.importClause.namedBindings) {
+        const namedBindings = statement.importClause.namedBindings;
+        if (import_typescript98.default.isNamespaceImport(namedBindings) && !typeImport) {
+          return import_typescript98.default.factory.createPropertyAccessExpression(import_typescript98.default.factory.createIdentifier(namedBindings.name.text), import_typescript98.default.factory.createIdentifier(alias || symbolName || "default"));
+        } else if (import_typescript98.default.isNamedImports(namedBindings) && symbolName) {
+          const existingElement = namedBindings.elements.find((e) => {
+            if (alias) {
+              return e.propertyName && e.name.text === alias && e.propertyName.text === symbolName;
+            }
+            return e.propertyName ? e.propertyName.text === symbolName : e.name.text === symbolName;
+          });
+          if (existingElement) {
+            return import_typescript98.default.factory.createIdentifier(existingElement.name.text);
           }
+          existingImport = statement;
         }
+      } else if (statement.importClause.name && !symbolName) {
+        return import_typescript98.default.factory.createIdentifier(statement.importClause.name.text);
       }
     }
-    return {
-      buildPaths: [...buildPaths],
-      testPaths: [...testPaths]
-    };
-  });
-}
-function* allTargetOptions(target) {
-  if (target.options) {
-    yield [void 0, target.options];
-  }
-  if (!target.configurations) {
-    return;
-  }
-  for (const [name, options] of Object.entries(target.configurations)) {
-    if (options) {
-      yield [name, options];
+    if (existingImport) {
+      const { propertyName, name } = this._getImportParts(sourceFile, symbolName, alias);
+      this.updatedImports.set(existingImport, (this.updatedImports.get(existingImport) || []).concat({ propertyName, importName: name }));
+      this.importCache.push({ sourceFile, moduleName, symbolName, alias, identifier: name });
+      return name;
     }
-  }
-}
-function createHost(tree) {
-  return {
-    readFile(path3) {
-      return __async(this, null, function* () {
-        const data = tree.read(path3);
-        if (!data) {
-          throw new Error("File not found.");
-        }
-        return import_core13.virtualFs.fileBufferToString(data);
-      });
-    },
-    writeFile(path3, data) {
-      return __async(this, null, function* () {
-        return tree.overwrite(path3, data);
+    let identifier = null;
+    if (!this.newImports.has(sourceFile)) {
+      this.newImports.set(sourceFile, {
+        importStartIndex,
+        defaultImports: /* @__PURE__ */ new Map(),
+        namedImports: /* @__PURE__ */ new Map()
       });
-    },
-    isDirectory(path3) {
-      return __async(this, null, function* () {
-        return !tree.exists(path3) && tree.getDir(path3).subfiles.length > 0;
+    }
+    if (symbolName) {
+      const { propertyName, name } = this._getImportParts(sourceFile, symbolName, alias);
+      const importMap = this.newImports.get(sourceFile).namedImports;
+      identifier = name;
+      if (!importMap.has(moduleName)) {
+        importMap.set(moduleName, []);
+      }
+      importMap.get(moduleName).push(import_typescript98.default.factory.createImportSpecifier(false, propertyName, name));
+    } else {
+      const importMap = this.newImports.get(sourceFile).defaultImports;
+      identifier = this._getUniqueIdentifier(sourceFile, "defaultExport");
+      importMap.set(moduleName, identifier);
+    }
+    this.importCache.push({ sourceFile, symbolName, moduleName, alias, identifier });
+    return identifier;
+  }
+  recordChanges() {
+    this.updatedImports.forEach((expressions, importDecl) => {
+      const sourceFile = importDecl.getSourceFile();
+      const recorder = this.getUpdateRecorder(sourceFile);
+      const namedBindings = importDecl.importClause.namedBindings;
+      const newNamedBindings = import_typescript98.default.factory.updateNamedImports(namedBindings, namedBindings.elements.concat(expressions.map(({ propertyName, importName }) => import_typescript98.default.factory.createImportSpecifier(false, propertyName, importName))));
+      const newNamedBindingsText = this.printer.printNode(import_typescript98.default.EmitHint.Unspecified, newNamedBindings, sourceFile);
+      recorder.updateExistingImport(namedBindings, newNamedBindingsText);
+    });
+    this.newImports.forEach(({ importStartIndex, defaultImports, namedImports }, sourceFile) => {
+      const recorder = this.getUpdateRecorder(sourceFile);
+      const useSingleQuotes = this._getQuoteStyle(sourceFile) === 0;
+      defaultImports.forEach((identifier, moduleName) => {
+        const newImport = import_typescript98.default.factory.createImportDeclaration(void 0, import_typescript98.default.factory.createImportClause(false, identifier, void 0), import_typescript98.default.factory.createStringLiteral(moduleName, useSingleQuotes));
+        recorder.addNewImport(importStartIndex, this._getNewImportText(importStartIndex, newImport, sourceFile));
       });
-    },
-    isFile(path3) {
-      return __async(this, null, function* () {
-        return tree.exists(path3);
+      namedImports.forEach((specifiers, moduleName) => {
+        const newImport = import_typescript98.default.factory.createImportDeclaration(void 0, import_typescript98.default.factory.createImportClause(false, void 0, import_typescript98.default.factory.createNamedImports(specifiers)), import_typescript98.default.factory.createStringLiteral(moduleName, useSingleQuotes));
+        recorder.addNewImport(importStartIndex, this._getNewImportText(importStartIndex, newImport, sourceFile));
       });
-    }
-  };
-}
-function getWorkspace(tree) {
-  return __async(this, null, function* () {
-    const host = createHost(tree);
-    const { workspace } = yield import_core13.workspaces.readWorkspace("/", host);
-    return workspace;
-  });
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/compiler_host.mjs
-var import_path4 = require("path");
-var import_typescript100 = __toESM(require("typescript"), 1);
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/parse_tsconfig.mjs
-var path2 = __toESM(require("path"), 1);
-var import_typescript99 = __toESM(require("typescript"), 1);
-function parseTsconfigFile(tsconfigPath, basePath) {
-  const { config } = import_typescript99.default.readConfigFile(tsconfigPath, import_typescript99.default.sys.readFile);
-  const parseConfigHost = {
-    useCaseSensitiveFileNames: import_typescript99.default.sys.useCaseSensitiveFileNames,
-    fileExists: import_typescript99.default.sys.fileExists,
-    readDirectory: import_typescript99.default.sys.readDirectory,
-    readFile: import_typescript99.default.sys.readFile
-  };
-  if (!path2.isAbsolute(basePath)) {
-    throw Error("Unexpected relative base path has been specified.");
-  }
-  return import_typescript99.default.parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/compiler_host.mjs
-function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles, optionOverrides) {
-  tsconfigPath = (0, import_path4.resolve)(basePath, tsconfigPath);
-  const parsed = parseTsconfigFile(tsconfigPath, (0, import_path4.dirname)(tsconfigPath));
-  const options = optionOverrides ? __spreadValues(__spreadValues({}, parsed.options), optionOverrides) : parsed.options;
-  const host = createMigrationCompilerHost(tree, options, basePath, fakeFileRead);
-  return { rootNames: parsed.fileNames.concat(additionalFiles || []), options, host };
-}
-function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
-  const host = import_typescript100.default.createCompilerHost(options, true);
-  const defaultReadFile = host.readFile;
-  host.readFile = (fileName) => {
-    var _a;
-    const treeRelativePath = (0, import_path4.relative)(basePath, fileName);
-    let result = fakeRead == null ? void 0 : fakeRead(treeRelativePath);
-    if (typeof result !== "string") {
-      result = treeRelativePath.startsWith("..") ? defaultReadFile.call(host, fileName) : (_a = tree.read(treeRelativePath)) == null ? void 0 : _a.toString();
-    }
-    return typeof result === "string" ? result.replace(/^\uFEFF/, "") : void 0;
-  };
-  return host;
-}
-function canMigrateFile(basePath, sourceFile, program) {
-  if (sourceFile.fileName.endsWith(".ngtypecheck.ts") || sourceFile.isDeclarationFile || program.isSourceFileFromExternalLibrary(sourceFile)) {
-    return false;
-  }
-  return !(0, import_path4.relative)(basePath, sourceFile.fileName).startsWith("..");
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/ng-generate/standalone-migration/prune-modules.mjs
-var import_typescript106 = __toESM(require("typescript"), 1);
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/decorators.mjs
-var import_typescript102 = __toESM(require("typescript"), 1);
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/imports.mjs
-var import_typescript101 = __toESM(require("typescript"), 1);
-function getImportOfIdentifier(typeChecker, node) {
-  const symbol = typeChecker.getSymbolAtLocation(node);
-  if (!symbol || symbol.declarations === void 0 || !symbol.declarations.length) {
-    return null;
-  }
-  const decl = symbol.declarations[0];
-  if (!import_typescript101.default.isImportSpecifier(decl)) {
-    return null;
-  }
-  const importDecl = decl.parent.parent.parent;
-  if (!import_typescript101.default.isStringLiteral(importDecl.moduleSpecifier)) {
-    return null;
-  }
-  return {
-    name: decl.propertyName ? decl.propertyName.text : decl.name.text,
-    importModule: importDecl.moduleSpecifier.text,
-    node: importDecl
-  };
-}
-function getImportSpecifier(sourceFile, moduleName, specifierName) {
-  var _a;
-  for (const node of sourceFile.statements) {
-    if (import_typescript101.default.isImportDeclaration(node) && import_typescript101.default.isStringLiteral(node.moduleSpecifier)) {
-      const isMatch = typeof moduleName === "string" ? node.moduleSpecifier.text === moduleName : moduleName.test(node.moduleSpecifier.text);
-      const namedBindings = (_a = node.importClause) == null ? void 0 : _a.namedBindings;
-      if (isMatch && namedBindings && import_typescript101.default.isNamedImports(namedBindings)) {
-        const match = findImportSpecifier(namedBindings.elements, specifierName);
-        if (match) {
-          return match;
-        }
-      }
-    }
-  }
-  return null;
-}
-function findImportSpecifier(nodes, specifierName) {
-  return nodes.find((element) => {
-    const { name, propertyName } = element;
-    return propertyName ? propertyName.text === specifierName : name.text === specifierName;
-  });
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/decorators.mjs
-function getCallDecoratorImport(typeChecker, decorator) {
-  if (!import_typescript102.default.isCallExpression(decorator.expression) || !import_typescript102.default.isIdentifier(decorator.expression.expression)) {
-    return null;
-  }
-  const identifier = decorator.expression.expression;
-  return getImportOfIdentifier(typeChecker, identifier);
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/ng_decorators.mjs
-function getAngularDecorators(typeChecker, decorators) {
-  return decorators.map((node) => ({ node, importData: getCallDecoratorImport(typeChecker, node) })).filter(({ importData }) => importData && importData.importModule.startsWith("@angular/")).map(({ node, importData }) => ({
-    node,
-    name: importData.name,
-    moduleName: importData.importModule,
-    importNode: importData.node
-  }));
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/nodes.mjs
-var import_typescript103 = __toESM(require("typescript"), 1);
-function closestNode(node, predicate) {
-  let current = node.parent;
-  while (current && !import_typescript103.default.isSourceFile(current)) {
-    if (predicate(current)) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/ng-generate/standalone-migration/util.mjs
-var import_path6 = require("path");
-var import_typescript105 = __toESM(require("typescript"), 1);
-
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/import_manager.mjs
-var import_path5 = require("path");
-var import_typescript104 = __toESM(require("typescript"), 1);
-var IS_AFTER_TS_492 = isAfterVersion2(4, 9);
-var ImportManager2 = class {
-  constructor(getUpdateRecorder, printer) {
-    this.getUpdateRecorder = getUpdateRecorder;
-    this.printer = printer;
-    this.updatedImports = /* @__PURE__ */ new Map();
-    this.usedIdentifierNames = /* @__PURE__ */ new Map();
-    this.newImports = /* @__PURE__ */ new Map();
-    this.quoteStyles = {};
-    this.importCache = [];
-  }
-  addImportToSourceFile(sourceFile, symbolName, moduleName, alias = null, typeImport = false) {
-    const sourceDir = (0, import_path5.dirname)(sourceFile.fileName);
-    let importStartIndex = 0;
-    let existingImport = null;
-    const cachedImport = this.importCache.find((c) => c.sourceFile === sourceFile && c.symbolName === symbolName && c.moduleName === moduleName && c.alias === alias);
-    if (cachedImport) {
-      return cachedImport.identifier;
-    }
-    for (let i = sourceFile.statements.length - 1; i >= 0; i--) {
-      const statement = sourceFile.statements[i];
-      if (!import_typescript104.default.isImportDeclaration(statement) || !import_typescript104.default.isStringLiteral(statement.moduleSpecifier) || !statement.importClause) {
-        continue;
-      }
-      if (importStartIndex === 0) {
-        importStartIndex = this._getEndPositionOfNode(statement);
-      }
-      const moduleSpecifier = statement.moduleSpecifier.text;
-      if (moduleSpecifier.startsWith(".") && (0, import_path5.resolve)(sourceDir, moduleSpecifier) !== (0, import_path5.resolve)(sourceDir, moduleName) || moduleSpecifier !== moduleName) {
-        continue;
-      }
-      if (statement.importClause.namedBindings) {
-        const namedBindings = statement.importClause.namedBindings;
-        if (import_typescript104.default.isNamespaceImport(namedBindings) && !typeImport) {
-          return import_typescript104.default.factory.createPropertyAccessExpression(import_typescript104.default.factory.createIdentifier(namedBindings.name.text), import_typescript104.default.factory.createIdentifier(alias || symbolName || "default"));
-        } else if (import_typescript104.default.isNamedImports(namedBindings) && symbolName) {
-          const existingElement = namedBindings.elements.find((e) => {
-            if (alias) {
-              return e.propertyName && e.name.text === alias && e.propertyName.text === symbolName;
-            }
-            return e.propertyName ? e.propertyName.text === symbolName : e.name.text === symbolName;
-          });
-          if (existingElement) {
-            return import_typescript104.default.factory.createIdentifier(existingElement.name.text);
-          }
-          existingImport = statement;
-        }
-      } else if (statement.importClause.name && !symbolName) {
-        return import_typescript104.default.factory.createIdentifier(statement.importClause.name.text);
-      }
-    }
-    if (existingImport) {
-      const { propertyName, name } = this._getImportParts(sourceFile, symbolName, alias);
-      this.updatedImports.set(existingImport, (this.updatedImports.get(existingImport) || []).concat({ propertyName, importName: name }));
-      this.importCache.push({ sourceFile, moduleName, symbolName, alias, identifier: name });
-      return name;
-    }
-    let identifier = null;
-    if (!this.newImports.has(sourceFile)) {
-      this.newImports.set(sourceFile, {
-        importStartIndex,
-        defaultImports: /* @__PURE__ */ new Map(),
-        namedImports: /* @__PURE__ */ new Map()
-      });
-    }
-    if (symbolName) {
-      const { propertyName, name } = this._getImportParts(sourceFile, symbolName, alias);
-      const importMap = this.newImports.get(sourceFile).namedImports;
-      identifier = name;
-      if (!importMap.has(moduleName)) {
-        importMap.set(moduleName, []);
-      }
-      importMap.get(moduleName).push(import_typescript104.default.factory.createImportSpecifier(false, propertyName, name));
-    } else {
-      const importMap = this.newImports.get(sourceFile).defaultImports;
-      identifier = this._getUniqueIdentifier(sourceFile, "defaultExport");
-      importMap.set(moduleName, identifier);
-    }
-    this.importCache.push({ sourceFile, symbolName, moduleName, alias, identifier });
-    return identifier;
-  }
-  recordChanges() {
-    this.updatedImports.forEach((expressions, importDecl) => {
-      const sourceFile = importDecl.getSourceFile();
-      const recorder = this.getUpdateRecorder(sourceFile);
-      const namedBindings = importDecl.importClause.namedBindings;
-      const newNamedBindings = import_typescript104.default.factory.updateNamedImports(namedBindings, namedBindings.elements.concat(expressions.map(({ propertyName, importName }) => import_typescript104.default.factory.createImportSpecifier(false, propertyName, importName))));
-      const newNamedBindingsText = this.printer.printNode(import_typescript104.default.EmitHint.Unspecified, newNamedBindings, sourceFile);
-      recorder.updateExistingImport(namedBindings, newNamedBindingsText);
-    });
-    this.newImports.forEach(({ importStartIndex, defaultImports, namedImports }, sourceFile) => {
-      const recorder = this.getUpdateRecorder(sourceFile);
-      const useSingleQuotes = this._getQuoteStyle(sourceFile) === 0;
-      defaultImports.forEach((identifier, moduleName) => {
-        const newImport = createImportDeclaration2(void 0, import_typescript104.default.factory.createImportClause(false, identifier, void 0), import_typescript104.default.factory.createStringLiteral(moduleName, useSingleQuotes));
-        recorder.addNewImport(importStartIndex, this._getNewImportText(importStartIndex, newImport, sourceFile));
-      });
-      namedImports.forEach((specifiers, moduleName) => {
-        const newImport = createImportDeclaration2(void 0, import_typescript104.default.factory.createImportClause(false, void 0, import_typescript104.default.factory.createNamedImports(specifiers)), import_typescript104.default.factory.createStringLiteral(moduleName, useSingleQuotes));
-        recorder.addNewImport(importStartIndex, this._getNewImportText(importStartIndex, newImport, sourceFile));
-      });
-    });
-  }
-  _getUniqueIdentifier(sourceFile, baseName) {
-    if (this.isUniqueIdentifierName(sourceFile, baseName)) {
-      this._recordUsedIdentifier(sourceFile, baseName);
-      return import_typescript104.default.factory.createIdentifier(baseName);
+    });
+  }
+  _getUniqueIdentifier(sourceFile, baseName) {
+    if (this.isUniqueIdentifierName(sourceFile, baseName)) {
+      this._recordUsedIdentifier(sourceFile, baseName);
+      return import_typescript98.default.factory.createIdentifier(baseName);
     }
     let name = null;
     let counter = 1;
@@ -34710,7 +34477,7 @@ var ImportManager2 = class {
       name = `${baseName}_${counter++}`;
     } while (!this.isUniqueIdentifierName(sourceFile, name));
     this._recordUsedIdentifier(sourceFile, name);
-    return import_typescript104.default.factory.createIdentifier(name);
+    return import_typescript98.default.factory.createIdentifier(name);
   }
   isUniqueIdentifierName(sourceFile, name) {
     if (this.usedIdentifierNames.has(sourceFile) && this.usedIdentifierNames.get(sourceFile).indexOf(name) !== -1) {
@@ -34719,7 +34486,7 @@ var ImportManager2 = class {
     const nodeQueue = [sourceFile];
     while (nodeQueue.length) {
       const node = nodeQueue.shift();
-      if (import_typescript104.default.isIdentifier(node) && node.text === name && (!import_typescript104.default.isImportSpecifier(node.parent) || node.parent.propertyName !== node)) {
+      if (import_typescript98.default.isIdentifier(node) && node.text === name && (!import_typescript98.default.isImportSpecifier(node.parent) || node.parent.propertyName !== node)) {
         return false;
       }
       nodeQueue.push(...node.getChildren());
@@ -34731,21 +34498,21 @@ var ImportManager2 = class {
   }
   _getEndPositionOfNode(node) {
     const nodeEndPos = node.getEnd();
-    const commentRanges = import_typescript104.default.getTrailingCommentRanges(node.getSourceFile().text, nodeEndPos);
+    const commentRanges = import_typescript98.default.getTrailingCommentRanges(node.getSourceFile().text, nodeEndPos);
     if (!commentRanges || !commentRanges.length) {
       return nodeEndPos;
     }
     return commentRanges[commentRanges.length - 1].end;
   }
   _getNewImportText(importStartIndex, newImport, sourceFile) {
-    const text = this.printer.printNode(import_typescript104.default.EmitHint.Unspecified, newImport, sourceFile);
+    const text = this.printer.printNode(import_typescript98.default.EmitHint.Unspecified, newImport, sourceFile);
     return importStartIndex === 0 ? `${text}
 ` : `
 ${text}`;
   }
   _getImportParts(sourceFile, symbolName, alias) {
-    const symbolIdentifier = import_typescript104.default.factory.createIdentifier(symbolName);
-    const aliasIdentifier = alias ? import_typescript104.default.factory.createIdentifier(alias) : null;
+    const symbolIdentifier = import_typescript98.default.factory.createIdentifier(symbolName);
+    const aliasIdentifier = alias ? import_typescript98.default.factory.createIdentifier(alias) : null;
     const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, alias || symbolName);
     const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== (alias || symbolName);
     let propertyName;
@@ -34765,7 +34532,7 @@ ${text}`;
     if (!this.quoteStyles.hasOwnProperty(sourceFile.fileName)) {
       let quoteStyle;
       for (const statement of sourceFile.statements) {
-        if (import_typescript104.default.isImportDeclaration(statement) && import_typescript104.default.isStringLiteralLike(statement.moduleSpecifier)) {
+        if (import_typescript98.default.isImportDeclaration(statement) && import_typescript98.default.isStringLiteralLike(statement.moduleSpecifier)) {
           quoteStyle = statement.moduleSpecifier.getText().trim().startsWith('"') ? 1 : 0;
           break;
         }
@@ -34775,18 +34542,8 @@ ${text}`;
     return this.quoteStyles[sourceFile.fileName];
   }
 };
-function createImportDeclaration2(modifiers, importClause, moduleSpecifier, assertClause) {
-  return IS_AFTER_TS_492 ? import_typescript104.default.factory.createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause) : import_typescript104.default.factory.createImportDeclaration(void 0, modifiers, importClause, moduleSpecifier, assertClause);
-}
-function isAfterVersion2(targetMajor, targetMinor) {
-  const [major, minor] = import_typescript104.default.versionMajorMinor.split(".").map((part) => parseInt(part));
-  if (major < targetMajor) {
-    return false;
-  }
-  return major === targetMajor ? minor >= targetMinor : true;
-}
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/ng-generate/standalone-migration/util.mjs
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/change_tracker.mjs
 var ChangeTracker = class {
   constructor(_printer, _importRemapper) {
     this._printer = _printer;
@@ -34803,7 +34560,7 @@ var ChangeTracker = class {
   replaceText(sourceFile, start, removeLength, text) {
     this._trackChange(sourceFile, { start, removeLength, text });
   }
-  replaceNode(oldNode, newNode, emitHint = import_typescript105.default.EmitHint.Unspecified, sourceFileWhenPrinting) {
+  replaceNode(oldNode, newNode, emitHint = import_typescript99.default.EmitHint.Unspecified, sourceFileWhenPrinting) {
     const sourceFile = oldNode.getSourceFile();
     this.replaceText(sourceFile, oldNode.getStart(), oldNode.getWidth(), this._printer.printNode(emitHint, newNode, sourceFileWhenPrinting || sourceFile));
   }
@@ -34812,7 +34569,7 @@ var ChangeTracker = class {
   }
   addImport(sourceFile, symbolName, moduleName, alias = null) {
     if (this._importRemapper) {
-      moduleName = this._importRemapper(moduleName);
+      moduleName = this._importRemapper(moduleName, sourceFile.fileName);
     }
     moduleName = normalizePath(moduleName);
     return this._importManager.addImportToSourceFile(sourceFile, symbolName, moduleName, alias);
@@ -34835,6 +34592,225 @@ var ChangeTracker = class {
     }
   }
 };
+function normalizePath(path3) {
+  return path3.replace(/\\/g, "/");
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/project_tsconfig_paths.mjs
+var import_core13 = require("@angular-devkit/core");
+function getProjectTsConfigPaths(tree) {
+  return __async(this, null, function* () {
+    const buildPaths = /* @__PURE__ */ new Set();
+    const testPaths = /* @__PURE__ */ new Set();
+    const workspace = yield getWorkspace(tree);
+    for (const [, project] of workspace.projects) {
+      for (const [name, target] of project.targets) {
+        if (name !== "build" && name !== "test") {
+          continue;
+        }
+        for (const [, options] of allTargetOptions(target)) {
+          const tsConfig = options.tsConfig;
+          if (typeof tsConfig !== "string" || !tree.exists(tsConfig)) {
+            continue;
+          }
+          if (name === "build") {
+            buildPaths.add((0, import_core13.normalize)(tsConfig));
+          } else {
+            testPaths.add((0, import_core13.normalize)(tsConfig));
+          }
+        }
+      }
+    }
+    return {
+      buildPaths: [...buildPaths],
+      testPaths: [...testPaths]
+    };
+  });
+}
+function* allTargetOptions(target) {
+  if (target.options) {
+    yield [void 0, target.options];
+  }
+  if (!target.configurations) {
+    return;
+  }
+  for (const [name, options] of Object.entries(target.configurations)) {
+    if (options) {
+      yield [name, options];
+    }
+  }
+}
+function createHost(tree) {
+  return {
+    readFile(path3) {
+      return __async(this, null, function* () {
+        const data = tree.read(path3);
+        if (!data) {
+          throw new Error("File not found.");
+        }
+        return import_core13.virtualFs.fileBufferToString(data);
+      });
+    },
+    writeFile(path3, data) {
+      return __async(this, null, function* () {
+        return tree.overwrite(path3, data);
+      });
+    },
+    isDirectory(path3) {
+      return __async(this, null, function* () {
+        return !tree.exists(path3) && tree.getDir(path3).subfiles.length > 0;
+      });
+    },
+    isFile(path3) {
+      return __async(this, null, function* () {
+        return tree.exists(path3);
+      });
+    }
+  };
+}
+function getWorkspace(tree) {
+  return __async(this, null, function* () {
+    const host = createHost(tree);
+    const { workspace } = yield import_core13.workspaces.readWorkspace("/", host);
+    return workspace;
+  });
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/compiler_host.mjs
+var import_path5 = require("path");
+var import_typescript101 = __toESM(require("typescript"), 1);
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/parse_tsconfig.mjs
+var path2 = __toESM(require("path"), 1);
+var import_typescript100 = __toESM(require("typescript"), 1);
+function parseTsconfigFile(tsconfigPath, basePath) {
+  const { config } = import_typescript100.default.readConfigFile(tsconfigPath, import_typescript100.default.sys.readFile);
+  const parseConfigHost = {
+    useCaseSensitiveFileNames: import_typescript100.default.sys.useCaseSensitiveFileNames,
+    fileExists: import_typescript100.default.sys.fileExists,
+    readDirectory: import_typescript100.default.sys.readDirectory,
+    readFile: import_typescript100.default.sys.readFile
+  };
+  if (!path2.isAbsolute(basePath)) {
+    throw Error("Unexpected relative base path has been specified.");
+  }
+  return import_typescript100.default.parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/compiler_host.mjs
+function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles, optionOverrides) {
+  tsconfigPath = (0, import_path5.resolve)(basePath, tsconfigPath);
+  const parsed = parseTsconfigFile(tsconfigPath, (0, import_path5.dirname)(tsconfigPath));
+  const options = optionOverrides ? __spreadValues(__spreadValues({}, parsed.options), optionOverrides) : parsed.options;
+  const host = createMigrationCompilerHost(tree, options, basePath, fakeFileRead);
+  return { rootNames: parsed.fileNames.concat(additionalFiles || []), options, host };
+}
+function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
+  const host = import_typescript101.default.createCompilerHost(options, true);
+  const defaultReadFile = host.readFile;
+  host.readFile = (fileName) => {
+    var _a;
+    const treeRelativePath = (0, import_path5.relative)(basePath, fileName);
+    let result = fakeRead == null ? void 0 : fakeRead(treeRelativePath);
+    if (typeof result !== "string") {
+      result = treeRelativePath.startsWith("..") ? defaultReadFile.call(host, fileName) : (_a = tree.read(treeRelativePath)) == null ? void 0 : _a.toString();
+    }
+    return typeof result === "string" ? result.replace(/^\uFEFF/, "") : void 0;
+  };
+  return host;
+}
+function canMigrateFile(basePath, sourceFile, program) {
+  if (sourceFile.fileName.endsWith(".ngtypecheck.ts") || sourceFile.isDeclarationFile || program.isSourceFileFromExternalLibrary(sourceFile)) {
+    return false;
+  }
+  return !(0, import_path5.relative)(basePath, sourceFile.fileName).startsWith("..");
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/ng-generate/standalone-migration/prune-modules.mjs
+var import_typescript106 = __toESM(require("typescript"), 1);
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/decorators.mjs
+var import_typescript103 = __toESM(require("typescript"), 1);
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/imports.mjs
+var import_typescript102 = __toESM(require("typescript"), 1);
+function getImportOfIdentifier(typeChecker, node) {
+  const symbol = typeChecker.getSymbolAtLocation(node);
+  if (!symbol || symbol.declarations === void 0 || !symbol.declarations.length) {
+    return null;
+  }
+  const decl = symbol.declarations[0];
+  if (!import_typescript102.default.isImportSpecifier(decl)) {
+    return null;
+  }
+  const importDecl = decl.parent.parent.parent;
+  if (!import_typescript102.default.isStringLiteral(importDecl.moduleSpecifier)) {
+    return null;
+  }
+  return {
+    name: decl.propertyName ? decl.propertyName.text : decl.name.text,
+    importModule: importDecl.moduleSpecifier.text,
+    node: importDecl
+  };
+}
+function getImportSpecifier(sourceFile, moduleName, specifierName) {
+  var _a;
+  for (const node of sourceFile.statements) {
+    if (import_typescript102.default.isImportDeclaration(node) && import_typescript102.default.isStringLiteral(node.moduleSpecifier)) {
+      const isMatch = typeof moduleName === "string" ? node.moduleSpecifier.text === moduleName : moduleName.test(node.moduleSpecifier.text);
+      const namedBindings = (_a = node.importClause) == null ? void 0 : _a.namedBindings;
+      if (isMatch && namedBindings && import_typescript102.default.isNamedImports(namedBindings)) {
+        const match = findImportSpecifier(namedBindings.elements, specifierName);
+        if (match) {
+          return match;
+        }
+      }
+    }
+  }
+  return null;
+}
+function findImportSpecifier(nodes, specifierName) {
+  return nodes.find((element) => {
+    const { name, propertyName } = element;
+    return propertyName ? propertyName.text === specifierName : name.text === specifierName;
+  });
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/decorators.mjs
+function getCallDecoratorImport(typeChecker, decorator) {
+  if (!import_typescript103.default.isCallExpression(decorator.expression) || !import_typescript103.default.isIdentifier(decorator.expression.expression)) {
+    return null;
+  }
+  const identifier = decorator.expression.expression;
+  return getImportOfIdentifier(typeChecker, identifier);
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/ng_decorators.mjs
+function getAngularDecorators(typeChecker, decorators) {
+  return decorators.map((node) => ({ node, importData: getCallDecoratorImport(typeChecker, node) })).filter(({ importData }) => importData && importData.importModule.startsWith("@angular/")).map(({ node, importData }) => ({
+    node,
+    name: importData.name,
+    moduleName: importData.importModule,
+    importNode: importData.node
+  }));
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/typescript/nodes.mjs
+var import_typescript104 = __toESM(require("typescript"), 1);
+function closestNode(node, predicate) {
+  let current = node.parent;
+  while (current && !import_typescript104.default.isSourceFile(current)) {
+    if (predicate(current)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+// bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/ng-generate/standalone-migration/util.mjs
+var import_path6 = require("path");
+var import_typescript105 = __toESM(require("typescript"), 1);
 var UniqueItemTracker = class {
   constructor() {
     this._nodes = /* @__PURE__ */ new Map();
@@ -34847,6 +34823,9 @@ var UniqueItemTracker = class {
       this._nodes.set(key, /* @__PURE__ */ new Set([item]));
     }
   }
+  get(key) {
+    return this._nodes.get(key);
+  }
   getEntries() {
     return this._nodes.entries();
   }
@@ -34978,9 +34957,6 @@ function getRelativeImportPath(fromFile, toFile) {
   }
   return normalizePath(path3);
 }
-function normalizePath(path3) {
-  return path3.replace(/\\/g, "/");
-}
 function knownInternalAliasRemapper(imports) {
   return imports.map((current) => current.moduleSpecifier === "@angular/common" && current.symbolName === "NgForOf" ? __spreadProps(__spreadValues({}, current), { symbolName: "NgFor" }) : current);
 }
@@ -35006,19 +34982,28 @@ function isClassReferenceInAngularModule(node, className, moduleName, typeChecke
 function pruneNgModules(program, host, basePath, rootFileNames, sourceFiles, printer, importRemapper, referenceLookupExcludedFiles) {
   const filesToRemove = /* @__PURE__ */ new Set();
   const tracker = new ChangeTracker(printer, importRemapper);
-  const typeChecker = program.getTsProgram().getTypeChecker();
+  const tsProgram = program.getTsProgram();
+  const typeChecker = tsProgram.getTypeChecker();
   const referenceResolver = new ReferenceResolver(program, host, rootFileNames, basePath, referenceLookupExcludedFiles);
   const removalLocations = {
     arrays: new UniqueItemTracker(),
     imports: new UniqueItemTracker(),
     exports: new UniqueItemTracker(),
-    classes: /* @__PURE__ */ new Set(),
     unknown: /* @__PURE__ */ new Set()
   };
+  const classesToRemove = /* @__PURE__ */ new Set();
+  const barrelExports = new UniqueItemTracker();
+  const nodesToRemove = /* @__PURE__ */ new Set();
   sourceFiles.forEach(function walk(node) {
+    var _a, _b;
     if (import_typescript106.default.isClassDeclaration(node) && canRemoveClass(node, typeChecker)) {
       collectRemovalLocations(node, removalLocations, referenceResolver, program);
-      removalLocations.classes.add(node);
+      classesToRemove.add(node);
+    } else if (import_typescript106.default.isExportDeclaration(node) && !node.exportClause && node.moduleSpecifier && import_typescript106.default.isStringLiteralLike(node.moduleSpecifier) && node.moduleSpecifier.text.startsWith(".")) {
+      const exportedSourceFile = (_b = (_a = typeChecker.getSymbolAtLocation(node.moduleSpecifier)) == null ? void 0 : _a.valueDeclaration) == null ? void 0 : _b.getSourceFile();
+      if (exportedSourceFile) {
+        barrelExports.track(exportedSourceFile, node);
+      }
     }
     node.forEachChild(walk);
   });
@@ -35026,9 +35011,22 @@ function pruneNgModules(program, host, basePath, rootFileNames, sourceFiles, pri
   removeImportReferences(removalLocations.imports, tracker);
   removeExportReferences(removalLocations.exports, tracker);
   addRemovalTodos(removalLocations.unknown, tracker);
-  for (const node of removalLocations.classes) {
+  (function trackNodesToRemove(nodes) {
+    for (const node of nodes) {
+      const sourceFile = node.getSourceFile();
+      if (!filesToRemove.has(sourceFile) && canRemoveFile(sourceFile, nodes)) {
+        const barrelExportsForFile = barrelExports.get(sourceFile);
+        nodesToRemove.add(node);
+        filesToRemove.add(sourceFile);
+        barrelExportsForFile && trackNodesToRemove(barrelExportsForFile);
+      } else {
+        nodesToRemove.add(node);
+      }
+    }
+  })(classesToRemove);
+  for (const node of nodesToRemove) {
     const sourceFile = node.getSourceFile();
-    if (!filesToRemove.has(sourceFile) && canRemoveFile(sourceFile, removalLocations.classes)) {
+    if (!filesToRemove.has(sourceFile) && canRemoveFile(sourceFile, nodesToRemove)) {
       filesToRemove.add(sourceFile);
     } else {
       tracker.removeNode(node);
@@ -35141,13 +35139,13 @@ function canRemoveClass(node, typeChecker) {
 function isNonEmptyNgModuleProperty(node) {
   return import_typescript106.default.isPropertyAssignment(node) && import_typescript106.default.isIdentifier(node.name) && import_typescript106.default.isArrayLiteralExpression(node.initializer) && node.initializer.elements.length > 0;
 }
-function canRemoveFile(sourceFile, classesToBeRemoved) {
+function canRemoveFile(sourceFile, nodesToBeRemoved) {
   var _a;
   for (const node of sourceFile.statements) {
-    if (import_typescript106.default.isImportDeclaration(node) || import_typescript106.default.isClassDeclaration(node) && classesToBeRemoved.has(node)) {
+    if (import_typescript106.default.isImportDeclaration(node) || nodesToBeRemoved.has(node)) {
       continue;
     }
-    if (import_typescript106.default.canHaveModifiers(node) && ((_a = import_typescript106.default.getModifiers(node)) == null ? void 0 : _a.some((m) => m.kind === import_typescript106.default.SyntaxKind.ExportKeyword))) {
+    if (import_typescript106.default.isExportDeclaration(node) || import_typescript106.default.canHaveModifiers(node) && ((_a = import_typescript106.default.getModifiers(node)) == null ? void 0 : _a.some((m) => m.kind === import_typescript106.default.SyntaxKind.ExportKeyword))) {
       return false;
     }
   }
@@ -35199,9 +35197,9 @@ function isReferenceToImport(typeChecker, node, importSpecifier) {
 function toStandalone(sourceFiles, program, printer, fileImportRemapper, componentImportRemapper) {
   const templateTypeChecker = program.compiler.getTemplateTypeChecker();
   const typeChecker = program.getTsProgram().getTypeChecker();
-  const modulesToMigrate = [];
-  const testObjectsToMigrate = [];
-  const declarations = [];
+  const modulesToMigrate = /* @__PURE__ */ new Set();
+  const testObjectsToMigrate = /* @__PURE__ */ new Set();
+  const declarations = /* @__PURE__ */ new Set();
   const tracker = new ChangeTracker(printer, fileImportRemapper);
   for (const sourceFile of sourceFiles) {
     const modules = findNgModuleClassesToMigrate(sourceFile, typeChecker);
@@ -35210,11 +35208,11 @@ function toStandalone(sourceFiles, program, printer, fileImportRemapper, compone
       const allModuleDeclarations = extractDeclarationsFromModule(module3, templateTypeChecker);
       const unbootstrappedDeclarations = filterNonBootstrappedDeclarations(allModuleDeclarations, module3, templateTypeChecker, typeChecker);
       if (unbootstrappedDeclarations.length > 0) {
-        modulesToMigrate.push(module3);
-        declarations.push(...unbootstrappedDeclarations);
+        modulesToMigrate.add(module3);
+        unbootstrappedDeclarations.forEach((decl) => declarations.add(decl));
       }
     }
-    testObjectsToMigrate.push(...testObjects);
+    testObjects.forEach((obj) => testObjectsToMigrate.add(obj));
   }
   for (const declaration of declarations) {
     convertNgModuleDeclarationToStandalone(declaration, declarations, tracker, templateTypeChecker, componentImportRemapper);
@@ -35225,46 +35223,46 @@ function toStandalone(sourceFiles, program, printer, fileImportRemapper, compone
   migrateTestDeclarations(testObjectsToMigrate, declarations, tracker, templateTypeChecker, typeChecker);
   return tracker.recordChanges();
 }
-function convertNgModuleDeclarationToStandalone(ref, allDeclarations, tracker, typeChecker, importRemapper) {
-  const directiveMeta = typeChecker.getDirectiveMetadata(ref.node);
+function convertNgModuleDeclarationToStandalone(decl, allDeclarations, tracker, typeChecker, importRemapper) {
+  const directiveMeta = typeChecker.getDirectiveMetadata(decl);
   if (directiveMeta && directiveMeta.decorator && !directiveMeta.isStandalone) {
     let decorator = addStandaloneToDecorator(directiveMeta.decorator);
     if (directiveMeta.isComponent) {
-      const importsToAdd = getComponentImportExpressions(ref, allDeclarations, tracker, typeChecker, importRemapper);
+      const importsToAdd = getComponentImportExpressions(decl, allDeclarations, tracker, typeChecker, importRemapper);
       if (importsToAdd.length > 0) {
         decorator = addPropertyToAngularDecorator(decorator, import_typescript108.default.factory.createPropertyAssignment("imports", import_typescript108.default.factory.createArrayLiteralExpression(importsToAdd)));
       }
     }
     tracker.replaceNode(directiveMeta.decorator, decorator);
   } else {
-    const pipeMeta = typeChecker.getPipeMetadata(ref.node);
+    const pipeMeta = typeChecker.getPipeMetadata(decl);
     if (pipeMeta && pipeMeta.decorator && !pipeMeta.isStandalone) {
       tracker.replaceNode(pipeMeta.decorator, addStandaloneToDecorator(pipeMeta.decorator));
     }
   }
 }
-function getComponentImportExpressions(ref, allDeclarations, tracker, typeChecker, importRemapper) {
-  const templateDependencies = findTemplateDependencies(ref, typeChecker);
-  const usedDependenciesInMigration = new Set(templateDependencies.filter((dep) => allDeclarations.find((current) => current.node === dep.node)));
+function getComponentImportExpressions(decl, allDeclarations, tracker, typeChecker, importRemapper) {
+  const templateDependencies = findTemplateDependencies(decl, typeChecker);
+  const usedDependenciesInMigration = new Set(templateDependencies.filter((dep) => allDeclarations.has(dep.node)));
   const imports = [];
   const seenImports = /* @__PURE__ */ new Set();
   const resolvedDependencies = [];
   for (const dep of templateDependencies) {
-    const importLocation = findImportLocation(dep, ref, usedDependenciesInMigration.has(dep) ? PotentialImportMode.ForceDirect : PotentialImportMode.Normal, typeChecker);
+    const importLocation = findImportLocation(dep, decl, usedDependenciesInMigration.has(dep) ? PotentialImportMode.ForceDirect : PotentialImportMode.Normal, typeChecker);
     if (importLocation && !seenImports.has(importLocation.symbolName)) {
       seenImports.add(importLocation.symbolName);
       resolvedDependencies.push(importLocation);
     }
   }
-  const processedDependencies = importRemapper ? importRemapper(resolvedDependencies, ref) : resolvedDependencies;
+  const processedDependencies = importRemapper ? importRemapper(resolvedDependencies, decl) : resolvedDependencies;
   for (const importLocation of processedDependencies) {
     if (importLocation.moduleSpecifier) {
-      const identifier = tracker.addImport(ref.node.getSourceFile(), importLocation.symbolName, importLocation.moduleSpecifier);
+      const identifier = tracker.addImport(decl.getSourceFile(), importLocation.symbolName, importLocation.moduleSpecifier);
       imports.push(identifier);
     } else {
       const identifier = import_typescript108.default.factory.createIdentifier(importLocation.symbolName);
       if (importLocation.isForwardReference) {
-        const forwardRefExpression = tracker.addImport(ref.node.getSourceFile(), "forwardRef", "@angular/core");
+        const forwardRefExpression = tracker.addImport(decl.getSourceFile(), "forwardRef", "@angular/core");
         const arrowFunction = import_typescript108.default.factory.createArrowFunction(void 0, void 0, [], void 0, void 0, identifier);
         imports.push(import_typescript108.default.factory.createCallExpression(forwardRefExpression, void 0, [arrowFunction]));
       } else {
@@ -35279,7 +35277,7 @@ function migrateNgModuleClass(node, allDeclarations, tracker, typeChecker, templ
   const decorator = (_a = templateTypeChecker.getNgModuleMetadata(node)) == null ? void 0 : _a.decorator;
   const metadata = decorator ? extractMetadataLiteral(decorator) : null;
   if (metadata) {
-    moveDeclarationsToImports(metadata, allDeclarations.map((decl) => decl.node), typeChecker, templateTypeChecker, tracker);
+    moveDeclarationsToImports(metadata, allDeclarations, typeChecker, templateTypeChecker, tracker);
   }
 }
 function moveDeclarationsToImports(literal3, allDeclarations, typeChecker, templateTypeChecker, tracker) {
@@ -35358,7 +35356,7 @@ function isNamedPropertyAssignment(node) {
   return import_typescript108.default.isPropertyAssignment(node) && node.name && import_typescript108.default.isIdentifier(node.name);
 }
 function findImportLocation(target, inComponent, importMode, typeChecker) {
-  const importLocations = typeChecker.getPotentialImportsFor(target, inComponent.node, importMode);
+  const importLocations = typeChecker.getPotentialImportsFor(target, inComponent, importMode);
   let firstSameFileImport = null;
   let firstModuleImport = null;
   for (const location of importLocations) {
@@ -35412,10 +35410,10 @@ function findTestObjectsToMigrate(sourceFile, typeChecker) {
   }
   return testObjects;
 }
-function findTemplateDependencies(ref, typeChecker) {
+function findTemplateDependencies(decl, typeChecker) {
   const results = [];
-  const usedDirectives = typeChecker.getUsedDirectives(ref.node);
-  const usedPipes = typeChecker.getUsedPipes(ref.node);
+  const usedDirectives = typeChecker.getUsedDirectives(decl);
+  const usedPipes = typeChecker.getUsedPipes(decl);
   if (usedDirectives !== null) {
     for (const dir of usedDirectives) {
       if (import_typescript108.default.isClassDeclaration(dir.ref.node)) {
@@ -35424,7 +35422,7 @@ function findTemplateDependencies(ref, typeChecker) {
     }
   }
   if (usedPipes !== null) {
-    const potentialPipes = typeChecker.getPotentialPipes(ref.node);
+    const potentialPipes = typeChecker.getPotentialPipes(decl);
     for (const pipe of potentialPipes) {
       if (import_typescript108.default.isClassDeclaration(pipe.ref.node) && usedPipes.some((current) => pipe.name === current)) {
         results.push(pipe.ref);
@@ -35452,27 +35450,27 @@ function filterNonBootstrappedDeclarations(declarations, ngModule, templateTypeC
       return [];
     }
   }
-  return declarations.filter((ref) => !bootstrappedClasses.has(ref.node));
+  return declarations.filter((ref) => !bootstrappedClasses.has(ref));
 }
 function extractDeclarationsFromModule(ngModule, templateTypeChecker) {
   const metadata = templateTypeChecker.getNgModuleMetadata(ngModule);
-  return metadata ? metadata.declarations.filter((decl) => import_typescript108.default.isClassDeclaration(decl.node)) : [];
+  return metadata ? metadata.declarations.filter((decl) => import_typescript108.default.isClassDeclaration(decl.node)).map((decl) => decl.node) : [];
 }
 function migrateTestDeclarations(testObjects, declarationsOutsideOfTestFiles, tracker, templateTypeChecker, typeChecker) {
   const { decorators, componentImports } = analyzeTestingModules(testObjects, typeChecker);
-  const allDeclarations = declarationsOutsideOfTestFiles.map((ref) => ref.node);
+  const allDeclarations = new Set(declarationsOutsideOfTestFiles);
   for (const decorator of decorators) {
     const closestClass = closestNode(decorator.node, import_typescript108.default.isClassDeclaration);
     if (decorator.name === "Pipe" || decorator.name === "Directive") {
       tracker.replaceNode(decorator.node, addStandaloneToDecorator(decorator.node));
       if (closestClass) {
-        allDeclarations.push(closestClass);
+        allDeclarations.add(closestClass);
       }
     } else if (decorator.name === "Component") {
       const newDecorator = addStandaloneToDecorator(decorator.node);
       const importsToAdd = componentImports.get(decorator.node);
       if (closestClass) {
-        allDeclarations.push(closestClass);
+        allDeclarations.add(closestClass);
       }
       if (importsToAdd && importsToAdd.size > 0) {
         tracker.replaceNode(decorator.node, addPropertyToAngularDecorator(newDecorator, import_typescript108.default.factory.createPropertyAssignment("imports", import_typescript108.default.factory.createArrayLiteralExpression(Array.from(importsToAdd)))));
@@ -35536,7 +35534,7 @@ function extractMetadataLiteral(decorator) {
   return import_typescript108.default.isCallExpression(decorator.expression) && decorator.expression.arguments.length === 1 && import_typescript108.default.isObjectLiteralExpression(decorator.expression.arguments[0]) ? decorator.expression.arguments[0] : null;
 }
 function isStandaloneDeclaration(node, declarationsInMigration, templateTypeChecker) {
-  if (declarationsInMigration.includes(node)) {
+  if (declarationsInMigration.has(node)) {
     return true;
   }
   const metadata = templateTypeChecker.getDirectiveMetadata(node) || templateTypeChecker.getPipeMetadata(node);
@@ -35550,8 +35548,9 @@ function toStandaloneBootstrap(program, host, basePath, rootFileNames, sourceFil
   const templateTypeChecker = program.compiler.getTemplateTypeChecker();
   const referenceResolver = new ReferenceResolver(program, host, rootFileNames, basePath, referenceLookupExcludedFiles);
   const bootstrapCalls = [];
-  const testObjects = [];
-  const allDeclarations = [];
+  const testObjects = /* @__PURE__ */ new Set();
+  const allDeclarations = /* @__PURE__ */ new Set();
+  const additionalProviders = hasImport(program, rootFileNames, "protractor") ? /* @__PURE__ */ new Map([["provideProtractorTestingSupport", "@angular/platform-browser"]]) : null;
   for (const sourceFile of sourceFiles) {
     sourceFile.forEachChild(function walk(node) {
       if (import_typescript109.default.isCallExpression(node) && import_typescript109.default.isPropertyAccessExpression(node.expression) && node.expression.name.text === "bootstrapModule" && isClassReferenceInAngularModule(node.expression, "PlatformRef", "core", typeChecker)) {
@@ -35562,11 +35561,11 @@ function toStandaloneBootstrap(program, host, basePath, rootFileNames, sourceFil
       }
       node.forEachChild(walk);
     });
-    testObjects.push(...findTestObjectsToMigrate(sourceFile, typeChecker));
+    findTestObjectsToMigrate(sourceFile, typeChecker).forEach((obj) => testObjects.add(obj));
   }
   for (const call of bootstrapCalls) {
-    allDeclarations.push(...call.declarations);
-    migrateBootstrapCall(call, tracker, referenceResolver, typeChecker, printer);
+    call.declarations.forEach((decl) => allDeclarations.add(decl));
+    migrateBootstrapCall(call, tracker, additionalProviders, referenceResolver, typeChecker, printer);
   }
   for (const declaration of allDeclarations) {
     convertNgModuleDeclarationToStandalone(declaration, allDeclarations, tracker, templateTypeChecker, componentImportRemapper);
@@ -35603,7 +35602,7 @@ function analyzeBootstrapCall(call, typeChecker, templateTypeChecker) {
   }
   return null;
 }
-function migrateBootstrapCall(analysis, tracker, referenceResolver, typeChecker, printer) {
+function migrateBootstrapCall(analysis, tracker, additionalProviders, referenceResolver, typeChecker, printer) {
   const sourceFile = analysis.call.getSourceFile();
   const moduleSourceFile = analysis.metadata.getSourceFile();
   const providers = findLiteralProperty(analysis.metadata, "providers");
@@ -35627,6 +35626,11 @@ function migrateBootstrapCall(analysis, tracker, referenceResolver, typeChecker,
     nodeLookup = nodeLookup || getNodeLookup(moduleSourceFile);
     migrateImportsForBootstrapCall(sourceFile, imports, nodeLookup, moduleImportsInNewCall, providersInNewCall, tracker, nodesToCopy, referenceResolver, typeChecker);
   }
+  if (additionalProviders) {
+    additionalProviders.forEach((moduleSpecifier, name) => {
+      providersInNewCall.push(import_typescript109.default.factory.createCallExpression(tracker.addImport(sourceFile, name, moduleSpecifier), void 0, void 0));
+    });
+  }
   if (nodesToCopy.size > 0) {
     let text = "\n\n";
     nodesToCopy.forEach((node) => {
@@ -35896,6 +35900,22 @@ function getLastImportEnd(sourceFile) {
   }
   return index;
 }
+function hasImport(program, rootFileNames, moduleName) {
+  const tsProgram = program.getTsProgram();
+  const deepImportStart = moduleName + "/";
+  for (const fileName of rootFileNames) {
+    const sourceFile = tsProgram.getSourceFile(fileName);
+    if (!sourceFile) {
+      continue;
+    }
+    for (const statement of sourceFile.statements) {
+      if (import_typescript109.default.isImportDeclaration(statement) && import_typescript109.default.isStringLiteralLike(statement.moduleSpecifier) && (statement.moduleSpecifier.text === moduleName || statement.moduleSpecifier.text.startsWith(deepImportStart))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/ng-generate/standalone-migration/index.mjs
 var MigrationMode;